.github/workflows/lint.yml

@@ -1,10 +0,0 @@
-name: lint
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-
-jobs:
-  lint:
-    uses: lnbits/lnbits/.github/workflows/lint.yml@dev

.github/workflows/release.yml

@@ -1,58 +1,19 @@
+name: release github version
 on:
   push:
     tags:
-      - 'v[0-9]+.[0-9]+.[0-9]+'
+      - "[0-9]+.[0-9]+.[0-9]+"
-
 jobs:
-  release:
+  build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - name: Create GitHub Release
-      - name: Create github release
+        id: create_release
+        uses: actions/create-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          tag: ${{ github.ref_name }}
-        run: |
-          gh release create "$tag" --generate-notes
-
-  pullrequest:
-    needs: [release]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
         with:
-          token: ${{ secrets.EXT_GITHUB }}
+          tag_name: ${{ github.ref }}
-          repository: lnbits/lnbits-extensions
+          release_name: ${{ github.ref }}
-          path: './lnbits-extensions'
+          draft: false
-
+          prerelease: false
-      - name: setup git user
-        run: |
-          git config --global user.name "alan"
-          git config --global user.email "alan@lnbits.com"
-
-      - name: Create pull request in extensions repo
-        env:
-          GH_TOKEN: ${{ secrets.EXT_GITHUB }}
-          repo_name: '${{ github.event.repository.name }}'
-          tag: '${{ github.ref_name }}'
-          branch: 'update-${{ github.event.repository.name }}-${{ github.ref_name }}'
-          title: '[UPDATE] ${{ github.event.repository.name }} to ${{ github.ref_name }}'
-          body: 'https://github.com/lnbits/${{ github.event.repository.name }}/releases/${{ github.ref_name }}'
-          archive: 'https://github.com/lnbits/${{ github.event.repository.name }}/archive/refs/tags/${{ github.ref_name }}.zip'
-        run: |
-          cd lnbits-extensions
-          git checkout -b $branch
-
-          # if there is another open PR
-          git pull origin $branch || echo "branch does not exist"
-
-          sh util.sh update_extension $repo_name $tag
-
-          git add -A
-          git commit -am "$title"
-          git push origin $branch
-
-          # check if pr exists before creating it
-          gh config set pager cat
-          check=$(gh pr list -H $branch | wc -l)
-          test $check -ne 0 || gh pr create --title "$title" --body "$body" --repo lnbits/lnbits-extensions

.gitignore

@@ -1,4 +1 @@
 __pycache__
-node_modules
-.mypy_cache
-.venv

.prettierrc

@@ -1,12 +0,0 @@
-{
-  "semi": false,
-  "arrowParens": "avoid",
-  "insertPragma": false,
-  "printWidth": 80,
-  "proseWrap": "preserve",
-  "singleQuote": true,
-  "trailingComma": "none",
-  "useTabs": false,
-  "bracketSameLine": false,
-  "bracketSpacing": false
-}

Makefile

@@ -1,47 +0,0 @@
-all: format check
-
-format: prettier black ruff
-
-check: mypy pyright checkblack checkruff checkprettier
-
-prettier:
-	uv run ./node_modules/.bin/prettier --write .
-pyright:
-	uv run ./node_modules/.bin/pyright
-
-mypy:
-	uv run mypy .
-
-black:
-	uv run black .
-
-ruff:
-	uv run ruff check . --fix
-
-checkruff:
-	uv run ruff check .
-
-checkprettier:
-	uv run ./node_modules/.bin/prettier --check .
-
-checkblack:
-	uv run black --check .
-
-checkeditorconfig:
-	editorconfig-checker
-
-test:
-	PYTHONUNBUFFERED=1 \
-	DEBUG=true \
-	uv run pytest
-install-pre-commit-hook:
-	@echo "Installing pre-commit hook to git"
-	@echo "Uninstall the hook with uv run pre-commit uninstall"
-	uv run pre-commit install
-
-pre-commit:
-	uv run pre-commit run --all-files
-
-
-checkbundle:
-	@echo "skipping checkbundle"

README.md

@@ -1,15 +1,4 @@
-<a href="https://lnbits.com" target="_blank" rel="noopener noreferrer">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://i.imgur.com/QE6SIrs.png">
-    <img src="https://i.imgur.com/fyKPgVT.png" alt="LNbits" style="width:280px">
-  </picture>
-</a>
-
-[![License: MIT](https://img.shields.io/badge/License-MIT-success?logo=open-source-initiative&logoColor=white)](./LICENSE)
-[![Built for LNbits](https://img.shields.io/badge/Built%20for-LNbits-4D4DFF?logo=lightning&logoColor=white)](https://github.com/lnbits/lnbits)
-
 # LNURLp - <small>[LNbits](https://github.com/lnbits/lnbits) extension</small>
-
 <small>For more about LNBits extension check [this tutorial](https://github.com/lnbits/lnbits/wiki/LNbits-Extensions)</small>
 
 ## Create a static QR code or LNaddress people can use to pay over Lightning Network
@@ -22,6 +11,7 @@ LNURL is a range of lightning-network standards that allow us to use lightning-n
 
 1. Create an LNURLp (New Pay link)\
    ![create lnurlp](https://i.imgur.com/rhUBJFy.jpg)
+
    - select your wallets
    - make a small description
    - enter amount
@@ -34,6 +24,7 @@ LNURL is a range of lightning-network standards that allow us to use lightning-n
 
 2. Use the shareable link or view the LNURLp you just created\
    ![LNURLp](https://i.imgur.com/C8s1P0Q.jpg)
+
    - you can now open your LNURLp and copy the LNURL, get the shareable link or print it\
      ![view lnurlp](https://i.imgur.com/4n41S7T.jpg)
 
@@ -45,11 +36,11 @@ LNURL is a range of lightning-network standards that allow us to use lightning-n
 ## Update your LNURL-pay extension
 
 Now that the extensions are taken out of core LNbits we can update each extension separately without the need to reload or restart LNbits as a whole.
-This new version of the extension will give you the option to add a Lightning Address to each LNURLpay link.
+This new version of the extension will give you the option to add a Lightning Address to each LNURLpay link. 
 
 - Open your LNbits instance as super admin (not as a regular user. You will find the SuperUser-ID in your server logs on restart of LNbits. Use that to bookmark and manage LNbits from there in the future.)
-  Now lets install the new version of a given extension like extensively [described in this guide](https://github.com/lnbits/lnbits/blob/main/docs/guide/extension-install.md#install-new-extension). In short:
+Now lets install the new version of a given extension like extensively [described in this guide](https://github.com/lnbits/lnbits/blob/main/docs/guide/extension-install.md#install-new-extension). In short:
-- Go to "Manage extensions", click on "ALL", search for e.g. LNURLp, click on "Manage"
+- Go to "Mange extensions", click on "ALL", search for e.g. LNURLp, click on "Manage"
 - Open the details of the extension and click on version 0.2.1, click "Install". You´re done!
 
 [![lnurl-p-1.jpg](https://i.postimg.cc/fTwDWD17/lnurl-p-1.jpg)](https://postimg.cc/xqFWtDfq)
@@ -64,11 +55,7 @@ Now you can receive sats to your newly created LN address. You will find this in
 
 [![lnurl-details.jpg](https://i.postimg.cc/zDwq1V2X/lnurl-details.jpg)](https://postimg.cc/3WwsXJHP)
 
+
 </details>
 
-## Powered by LNbits
 
-[LNbits](https://lnbits.com) is a free and open-source lightning accounts system.
-
-[![Visit LNbits Shop](https://img.shields.io/badge/Visit-LNbits%20Shop-7C3AED?logo=shopping-cart&logoColor=white&labelColor=5B21B6)](https://shop.lnbits.com/)
-[![Try myLNbits SaaS](https://img.shields.io/badge/Try-myLNbits%20SaaS-2563EB?logo=lightning&logoColor=white&labelColor=1E40AF)](https://my.lnbits.com/login)

__init__.py

@@ -1,16 +1,41 @@
 import asyncio
+from typing import List
 
 from fastapi import APIRouter
+from fastapi.staticfiles import StaticFiles
 
-from .crud import db
+from lnbits.db import Database
-from .tasks import wait_for_paid_invoices
+from lnbits.helpers import template_renderer
-from .views import lnurlp_generic_router
+from lnbits.tasks import catch_everything_and_restart
-from .views_api import lnurlp_api_router
+from loguru import logger
-from .views_lnurl import lnurlp_lnurl_router
+
+
+from .nostr.event import Event
+from .nostr.key import PrivateKey, PublicKey
+from environs import Env
+
+
+def generate_keys(private_key: str = ""):
+    if private_key.startswith("nsec"):
+        return PrivateKey.from_nsec(private_key)
+    elif private_key:
+        return PrivateKey(bytes.fromhex(private_key))
+    else:
+        return PrivateKey()  # generate random key
+
+
+env = Env()
+env.read_env()
+nostr_privatekey = generate_keys(env.str("LNURLP_ZAP_NOSTR_PRIVATEKEY", default=""))
+nostr_publickey: PublicKey = nostr_privatekey.public_key
+logger.debug(f"LNURLP Zaps Nostr pubkey: {nostr_publickey.hex()}")
+
+db = Database("ext_lnurlp")
 
 lnurlp_static_files = [
     {
         "path": "/lnurlp/static",
+        "app": StaticFiles(packages=[("lnbits", "extensions/lnurlp/static")]),
         "name": "lnurlp_static",
     }
 ]
@@ -22,68 +47,22 @@ lnurlp_redirect_paths = [
     }
 ]
 
+scheduled_tasks: List[asyncio.Task] = []
 
 lnurlp_ext: APIRouter = APIRouter(prefix="/lnurlp", tags=["lnurlp"])
-lnurlp_ext.include_router(lnurlp_generic_router)
-lnurlp_ext.include_router(lnurlp_api_router)
-lnurlp_ext.include_router(lnurlp_lnurl_router)
-
-scheduled_tasks: list[asyncio.Task] = []
 
 
-def lnurlp_stop():
+def lnurlp_renderer():
-    for task in scheduled_tasks:
+    return template_renderer(["lnbits/extensions/lnurlp/templates"])
-        task.cancel()
+
+
+from .lnurl import *  # noqa: F401,F403
+from .tasks import wait_for_paid_invoices
+from .views import *  # noqa: F401,F403
+from .views_api import *  # noqa: F401,F403
 
 
 def lnurlp_start():
-    from lnbits.tasks import create_permanent_unique_task
+    loop = asyncio.get_event_loop()
-
+    task = loop.create_task(catch_everything_and_restart(wait_for_paid_invoices))
-    task = create_permanent_unique_task("lnurlp", wait_for_paid_invoices)
     scheduled_tasks.append(task)
-
-    # Expose lnurlp's CRUD over the LNbits nostr transport so an HTTP-
-    # allergic client (e.g. lamassu-next ATM) can manage PayLinks over
-    # kind-21000 encrypted events. Also wires the link-owner resolver so
-    # `subscribe_payments({tag:"lnurlp", link_id:...})` can verify
-    # ownership of the underlying wallet. No-op if the core transport
-    # module isn't present in the LNbits build.
-    try:
-        from lnbits.core.services.nostr_transport.dispatcher import (
-            AUTH_ACCOUNT,
-            AUTH_WALLET,
-            register_rpc,
-        )
-        from lnbits.core.services.nostr_transport.subscriptions import (
-            register_link_owner_resolver,
-        )
-    except ImportError:
-        return
-
-    from .transport_rpcs import (
-        handle_lnurlp_create,
-        handle_lnurlp_delete,
-        handle_lnurlp_get,
-        handle_lnurlp_list,
-        handle_lnurlp_update,
-        resolve_lnurlp_owner,
-    )
-
-    register_rpc("lnurlp_create", handle_lnurlp_create, AUTH_WALLET)
-    register_rpc("lnurlp_get", handle_lnurlp_get, AUTH_WALLET)
-    register_rpc("lnurlp_list", handle_lnurlp_list, AUTH_ACCOUNT)
-    register_rpc("lnurlp_update", handle_lnurlp_update, AUTH_WALLET)
-    register_rpc("lnurlp_delete", handle_lnurlp_delete, AUTH_WALLET)
-    # lnurlp stamps `extra["link"] = link.id` on settlement
-    # (views_lnurl.py:86), which is the default extras-key, so no override.
-    register_link_owner_resolver("lnurlp", resolve_lnurlp_owner)
-
-
-__all__ = [
-    "db",
-    "lnurlp_ext",
-    "lnurlp_redirect_paths",
-    "lnurlp_start",
-    "lnurlp_static_files",
-    "lnurlp_stop",
-]

config.json

@@ -1,62 +1,6 @@
 {
-  "id": "paylink",
+  "name": "LNURLp",
-  "version": "1.3.0",
+  "short_description": "Make reusable LNURL pay links",
-  "name": "Pay Links",
-  "repo": "https://github.com/lnbits/lnurlp",
-  "short_description": "Make static reusable LNURL pay links or lightning addresses",
-  "description": "",
   "tile": "/lnurlp/static/image/lnurl-pay.png",
-  "min_lnbits_version": "1.4.0",
+  "contributors": ["arcbtc", "eillarra", "fiatjaf", "callebtc"]
-  "contributors": [
-    {
-      "name": "arcbtc",
-      "uri": "https://github.com/arcbtc",
-      "role": "Contributor"
-    },
-    {
-      "name": "eillarra",
-      "uri": "https://github.com/eillarra",
-      "role": "Contributor"
-    },
-    {
-      "name": "fiatjaf",
-      "uri": "https://github.com/fiatjaf",
-      "role": "Contributor"
-    },
-    {
-      "name": "callebtc",
-      "uri": "https://github.com/callebtc",
-      "role": "Contributor"
-    },
-    {
-      "name": "dni",
-      "uri": "https://github.com/dni",
-      "role": "Contributor"
-    }
-  ],
-  "images": [
-    {
-      "uri": "https://raw.githubusercontent.com/lnbits/lnurlp/main/static/image/1.jpg",
-      "link": "https://www.youtube.com/embed/WZpK4xfGcuY?si=_T3gCqKBU8yt6_bD"
-    },
-    {
-      "uri": "https://raw.githubusercontent.com/lnbits/lnurlp/main/static/image/1.png"
-    },
-    {
-      "uri": "https://raw.githubusercontent.com/lnbits/lnurlp/main/static/image/2.png"
-    },
-    {
-      "uri": "https://raw.githubusercontent.com/lnbits/lnurlp/main/static/image/3.png"
-    },
-    {
-      "uri": "https://raw.githubusercontent.com/lnbits/lnurlp/main/static/image/4.png"
-    }
-  ],
-  "description_md": "https://raw.githubusercontent.com/lnbits/lnurlp/main/description.md",
-  "terms_and_conditions_md": "https://raw.githubusercontent.com/lnbits/lnurlp/main/toc.md",
-  "license": "MIT",
-  "paid_features": "",
-  "tags": ["Merchant", "Payments"],
-  "donate": "",
-  "hidden": false
 }

crud.py

@@ -1,108 +1,142 @@
-from datetime import datetime, timezone
+import re
+from typing import List, Optional, Union
 
-from lnbits.db import Database
 from lnbits.helpers import urlsafe_short_hash
-from pynostr.key import PrivateKey
 
-from .models import CreatePayLinkData, LnurlpSettings, PayLink
+from . import db  # , maindb
+from .models import CreatePayLinkData, PayLink
+from .services import check_lnaddress_format
 
-db = Database("ext_lnurlp")
+# from loguru import logger
 
 
-async def get_or_create_lnurlp_settings() -> LnurlpSettings:
+async def check_lnaddress_update(username: str, id: str) -> bool:
-    settings = await db.fetchone(
+    # check no duplicates for lnaddress when updating an username
-        "SELECT * FROM lnurlp.settings LIMIT 1", model=LnurlpSettings
+    row = await db.fetchall(
+        "SELECT username FROM lnurlp.pay_links WHERE username = ? AND id = ?",
+        (username, id),
     )
-    if settings:
+    if row:
-        return settings
+        raise Exception("Username already exists. Try a different one.")
     else:
-        settings = LnurlpSettings(nostr_private_key=PrivateKey().hex())
+        return True
-        await db.insert("lnurlp.settings", settings)
-        return settings
 
 
-async def update_lnurlp_settings(settings: LnurlpSettings) -> LnurlpSettings:
+async def check_lnaddress_not_exists(username: str) -> bool:
-    await db.update("lnurlp.settings", settings, "")
+    # check if lnaddress username exists in the database when creating a new entry
-    return settings
+    row = await db.fetchall(
-
+        "SELECT username FROM lnurlp.pay_links WHERE username = ?", (username,)
-
-async def delete_lnurlp_settings() -> None:
-    await db.execute("DELETE FROM lnurlp.settings")
-
-
-async def get_pay_link_by_username(username: str) -> PayLink | None:
-    return await db.fetchone(
-        "SELECT * FROM lnurlp.pay_links WHERE username = :username",
-        {"username": username},
-        PayLink,
     )
+    if row:
+        raise Exception("Username already exists. Try a different one.")
+    else:
+        return True
 
 
-async def create_pay_link(data: CreatePayLinkData) -> PayLink:
+async def create_pay_link(data: CreatePayLinkData, wallet_id: str) -> PayLink:
+    if data.username:
+        await check_lnaddress_format(data.username)
+        await check_lnaddress_not_exists(data.username)
+
     link_id = urlsafe_short_hash()[:6]
 
-    assert data.wallet, "Wallet is required"
+    result = await db.execute(
-    now = datetime.now(timezone.utc)
+        """
+        INSERT INTO lnurlp.pay_links (
+            id,
+            wallet,
+            description,
+            min,
+            max,
+            served_meta,
+            served_pr,
+            webhook_url,
+            webhook_headers,
+            webhook_body,
+            success_text,
+            success_url,
+            comment_chars,
+            currency,
+            fiat_base_multiplier,
+            username,
+            zaps
 
-    link = PayLink(
+        )
-        id=link_id,
+        VALUES (?, ?, ?, ?, ?, 0, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        wallet=data.wallet,
+        """,
-        description=data.description,
+        (
-        min=data.min,
+            link_id,
-        max=data.max,
+            wallet_id,
-        served_meta=0,
+            data.description,
-        served_pr=0,
+            data.min,
-        username=data.username,
+            data.max,
-        zaps=data.zaps,
+            data.webhook_url,
-        webhook_url=data.webhook_url,
+            data.webhook_headers,
-        webhook_headers=data.webhook_headers,
+            data.webhook_body,
-        webhook_body=data.webhook_body,
+            data.success_text,
-        success_text=data.success_text,
+            data.success_url,
-        success_url=data.success_url,
+            data.comment_chars,
-        currency=data.currency,
+            data.currency,
-        comment_chars=data.comment_chars,
+            data.fiat_base_multiplier,
-        fiat_base_multiplier=data.fiat_base_multiplier,
+            data.username,
-        created_at=now,
+            data.zaps,
-        updated_at=now,
+        ),
-        disposable=data.disposable if data.disposable is not None else True,
-        domain=data.domain,
     )
+    assert result
 
-    await db.insert("lnurlp.pay_links", link)
+    link = await get_pay_link(link_id)
+    assert link, "Newly created link couldn't be retrieved"
     return link
 
 
-async def get_address_data(username: str) -> PayLink | None:
+async def get_address_data(username: str) -> Optional[PayLink]:
-    return await db.fetchone(
+    row = await db.fetchone(
-        "SELECT * FROM lnurlp.pay_links WHERE username = :username",
+        "SELECT * FROM lnurlp.pay_links WHERE username = ?", (username,)
-        {"username": username},
-        PayLink,
     )
+    return PayLink.from_row(row) if row else None
 
 
-async def get_pay_link(link_id: str) -> PayLink | None:
+async def get_pay_link(link_id: str) -> Optional[PayLink]:
-    return await db.fetchone(
+    row = await db.fetchone("SELECT * FROM lnurlp.pay_links WHERE id = ?", (link_id,))
-        "SELECT * FROM lnurlp.pay_links WHERE id = :id",
+    return PayLink.from_row(row) if row else None
-        {"id": link_id},
-        PayLink,
-    )
 
 
-async def get_pay_links(wallet_ids: str | list[str]) -> list[PayLink]:
+async def get_pay_links(wallet_ids: Union[str, List[str]]) -> List[PayLink]:
     if isinstance(wallet_ids, str):
         wallet_ids = [wallet_ids]
-    q = ",".join([f"'{wallet_id}'" for wallet_id in wallet_ids])
+
-    return await db.fetchall(
+    q = ",".join(["?"] * len(wallet_ids))
-        f"SELECT * FROM lnurlp.pay_links WHERE wallet IN ({q}) ORDER BY Id",
+    rows = await db.fetchall(
-        model=PayLink,
+        f"""
+        SELECT * FROM lnurlp.pay_links WHERE wallet IN ({q})
+        ORDER BY Id
+        """,
+        (*wallet_ids,),
     )
+    return [PayLink.from_row(row) for row in rows]
 
 
-async def update_pay_link(link: PayLink) -> PayLink:
+async def update_pay_link(link_id: str, **kwargs) -> Optional[PayLink]:
-    link.updated_at = datetime.now(timezone.utc)
+    if "lnaddress" in kwargs:
-    await db.update("lnurlp.pay_links", link)
+        await check_lnaddress_format(kwargs["lnaddress"])
-    return link
+        await check_lnaddress_update(kwargs["lnaddress"], link_id)
+
+    q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
+    await db.execute(
+        f"UPDATE lnurlp.pay_links SET {q} WHERE id = ?", (*kwargs.values(), link_id)
+    )
+    row = await db.fetchone("SELECT * FROM lnurlp.pay_links WHERE id = ?", (link_id,))
+    return PayLink.from_row(row) if row else None
+
+
+async def increment_pay_link(link_id: str, **kwargs) -> Optional[PayLink]:
+    q = ", ".join([f"{field[0]} = {field[0]} + ?" for field in kwargs.items()])
+    await db.execute(
+        f"UPDATE lnurlp.pay_links SET {q} WHERE id = ?", (*kwargs.values(), link_id)
+    )
+    row = await db.fetchone("SELECT * FROM lnurlp.pay_links WHERE id = ?", (link_id,))
+    return PayLink.from_row(row) if row else None
 
 
 async def delete_pay_link(link_id: str) -> None:
-    await db.execute("DELETE FROM lnurlp.pay_links WHERE id = :id", {"id": link_id})
+    await db.execute("DELETE FROM lnurlp.pay_links WHERE id = ?", (link_id,))

description.md

@@ -1,10 +0,0 @@
-Create static LNURL-pay links and Lightning addresses for receiving payments.
-
-Its functions include:
-
-- Generating reusable LNURL-pay QR codes
-- Creating custom Lightning addresses
-- Setting minimum and maximum payment amounts
-- Adding payment descriptions and metadata
-
-A foundational tool for anyone who wants a simple, reusable way to receive Lightning payments with a static QR code or Lightning address.

helpers.py

@@ -1,25 +0,0 @@
-from fastapi import Request
-from lnurl import encode as lnurl_encode
-from pynostr.key import PrivateKey
-
-
-def parse_nostr_private_key(key: str) -> PrivateKey:
-    if key.startswith("nsec"):
-        return PrivateKey.from_nsec(key)
-    else:
-        return PrivateKey(bytes.fromhex(key))
-
-
-def lnurl_encode_link(req: Request, link_id: str, domain: str | None = None) -> str:
-    if domain:
-        url_str = f"https://{domain}/lnurlp/{link_id}"
-        return str(lnurl_encode(url_str).bech32)
-
-    url = req.url_for("lnurlp.api_lnurl_response", link_id=link_id)
-    url = url.replace(path=url.path)
-    url_str = str(url)
-    if url.netloc.endswith(".onion"):
-        # change url string scheme to http
-        url_str = url_str.replace("https://", "http://")
-
-    return str(lnurl_encode(url_str).bech32)

lnurl.py

@@ -0,0 +1,151 @@
+from http import HTTPStatus
+
+from fastapi import Request, Query
+from lnurl import LnurlErrorResponse, LnurlPayActionResponse, LnurlPayResponse
+from starlette.exceptions import HTTPException
+
+from lnbits.core.services import create_invoice
+from lnbits.utils.exchange_rates import get_fiat_rate_satoshis
+
+from . import lnurlp_ext
+from .crud import increment_pay_link, get_pay_link, get_address_data
+from loguru import logger
+from urllib.parse import urlparse
+import json
+from . import nostr_publickey
+
+
+@lnurlp_ext.get(
+    "/api/v1/lnurl/cb/lnaddr/{link_id}",
+    status_code=HTTPStatus.OK,
+    name="lnurlp.api_lnurl_lnaddr_callback",
+)
+async def api_lnurl_lnaddr_callback(
+    request: Request, link_id, amount: int = Query(...)
+):
+    return await api_lnurl_callback(request, link_id, amount, lnaddress=True)
+
+
+@lnurlp_ext.get(
+    "/api/v1/lnurl/cb/{link_id}",
+    status_code=HTTPStatus.OK,
+    name="lnurlp.api_lnurl_callback",
+)
+async def api_lnurl_callback(
+    request: Request, link_id, amount: int = Query(...), lnaddress=False
+):
+    link = await increment_pay_link(link_id, served_pr=1)
+    if not link:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="Pay link does not exist."
+        )
+    min, max = link.min, link.max
+    rate = await get_fiat_rate_satoshis(link.currency) if link.currency else 1
+    if link.currency:
+        # allow some fluctuation (as the fiat price may have changed between the calls)
+        min = rate * 995 * link.min
+        max = rate * 1010 * link.max
+    else:
+        min = link.min * 1000
+        max = link.max * 1000
+
+    amount = amount
+    if amount < min:
+        return LnurlErrorResponse(
+            reason=f"Amount {amount} is smaller than minimum {min}."
+        ).dict()
+
+    elif amount > max:
+        return LnurlErrorResponse(
+            reason=f"Amount {amount} is greater than maximum {max}."
+        ).dict()
+
+    comment = request.query_params.get("comment")
+    if len(comment or "") > link.comment_chars:
+        return LnurlErrorResponse(
+            reason=f"Got a comment with {len(comment)} characters, but can only accept {link.comment_chars}"
+        ).dict()
+
+    if lnaddress:
+        # for lnaddress, we have to set this otherwise the metadata won't have the identifier
+        link.domain = urlparse(str(request.url)).netloc
+
+    extra = {
+        "tag": "lnurlp",
+        "link": link.id,
+        "extra": request.query_params.get("amount"),
+    }
+
+    if comment:
+        extra["comment"] = (comment,)
+
+    # nip 57
+    nostr = request.query_params.get("nostr")
+    if nostr:
+        extra["nostr"] = nostr  # put it here for later publishing in tasks.py
+
+    if lnaddress and link.username and link.domain:
+        extra["lnaddress"] = f"{link.username}@{link.domain}"
+
+    payment_hash, payment_request = await create_invoice(
+        wallet_id=link.wallet,
+        amount=int(amount / 1000),
+        memo=link.description,
+        unhashed_description=nostr.encode()
+        if nostr  # we take the zap request as the description instead of the LNURL metadata if present
+        else link.lnurlpay_metadata.encode(),
+        extra=extra,
+    )
+
+    success_action = link.success_action(payment_hash)
+    if success_action:
+        resp = LnurlPayActionResponse(
+            pr=payment_request, success_action=success_action, routes=[]  # type: ignore
+        )
+    else:
+        resp = LnurlPayActionResponse(pr=payment_request, routes=[])  # type: ignore
+
+    return resp.dict()
+
+
+@lnurlp_ext.get(
+    "/api/v1/lnurl/{link_id}",  # Backwards compatibility for old LNURLs / QR codes (with long URL)
+    status_code=HTTPStatus.OK,
+    name="lnurlp.api_lnurl_response.deprecated",
+)
+@lnurlp_ext.get(
+    "/{link_id}",
+    status_code=HTTPStatus.OK,
+    name="lnurlp.api_lnurl_response",
+)
+async def api_lnurl_response(request: Request, link_id, lnaddress=False):
+    link = await increment_pay_link(link_id, served_meta=1)
+    if not link:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="Pay link does not exist."
+        )
+
+    rate = await get_fiat_rate_satoshis(link.currency) if link.currency else 1
+
+    if lnaddress:
+        # for lnaddress, we have to set this otherwise the metadata won't have the identifier
+        link.domain = urlparse(str(request.url)).netloc
+        callback = str(request.url_for("lnurlp.api_lnurl_lnaddr_callback", link_id=link.id))
+    else:
+        callback = str(request.url_for("lnurlp.api_lnurl_callback", link_id=link.id))
+
+    resp = LnurlPayResponse(
+        callback=callback,
+        min_sendable=round(link.min * rate) * 1000,  # type: ignore
+        max_sendable=round(link.max * rate) * 1000,  # type: ignore
+        metadata=link.lnurlpay_metadata,
+    )
+    params = resp.dict()
+
+    if link.comment_chars > 0:
+        params["commentAllowed"] = link.comment_chars
+
+    if link.zaps:
+        params["allowsNostr"] = True
+        params["nostrPubkey"] = nostr_publickey.hex()
+    return params

migrations.py

@@ -1,13 +1,9 @@
-from time import time
-
-from lnbits.db import Connection
-
-
 async def m001_initial(db):
     """
     Initial pay table.
     """
-    await db.execute(f"""
+    await db.execute(
+        f"""
         CREATE TABLE lnurlp.pay_links (
             id {db.serial_primary_key},
             wallet TEXT NOT NULL,
@@ -16,7 +12,8 @@ async def m001_initial(db):
             served_meta INTEGER NOT NULL,
             served_pr INTEGER NOT NULL
         );
-        """)
+        """
+    )
 
 
 async def m002_webhooks_and_success_actions(db):
@@ -26,14 +23,16 @@ async def m002_webhooks_and_success_actions(db):
     await db.execute("ALTER TABLE lnurlp.pay_links ADD COLUMN webhook_url TEXT;")
     await db.execute("ALTER TABLE lnurlp.pay_links ADD COLUMN success_text TEXT;")
     await db.execute("ALTER TABLE lnurlp.pay_links ADD COLUMN success_url TEXT;")
-    await db.execute(f"""
+    await db.execute(
+        f"""
         CREATE TABLE lnurlp.invoices (
             pay_link INTEGER NOT NULL REFERENCES {db.references_schema}pay_links (id),
             payment_hash TEXT NOT NULL,
             webhook_sent INT, -- null means not sent, otherwise store status
             expiry INT
         );
-        """)
+        """
+    )
 
 
 async def m003_min_max_comment_fiat(db):
@@ -59,8 +58,7 @@ async def m004_fiat_base_multiplier(db):
     remember to multiply by 100 when we use it to convert to Dollars.
     """
     await db.execute(
-        "ALTER TABLE lnurlp.pay_links "
+        "ALTER TABLE lnurlp.pay_links ADD COLUMN fiat_base_multiplier INTEGER DEFAULT 1;"
-        "ADD COLUMN fiat_base_multiplier INTEGER DEFAULT 1;"
     )
 
 
@@ -82,7 +80,8 @@ async def m006_redux(db):
     else:
         # but we have to do this for sqlite
         await db.execute("ALTER TABLE lnurlp.pay_links RENAME TO pay_links_old")
-        await db.execute(f"""
+        await db.execute(
+            f"""
             CREATE TABLE lnurlp.pay_links (
                 id TEXT PRIMARY KEY,
                 wallet TEXT NOT NULL,
@@ -100,7 +99,8 @@ async def m006_redux(db):
                 webhook_headers TEXT,
                 webhook_body TEXT
                 );
-            """)
+            """
+        )
 
         for row in [
             list(row) for row in await db.fetchall("SELECT * FROM lnurlp.pay_links_old")
@@ -160,49 +160,3 @@ async def m008_add_zap_enabled_column(db):
     Add Nostr zaps to pay links
     """
     await db.execute("ALTER TABLE lnurlp.pay_links ADD COLUMN zaps BOOLEAN;")
-
-
-async def m009_add_settings(db):
-    """
-    Add extension settings table
-    """
-    await db.execute("""
-        CREATE TABLE lnurlp.settings (
-            nostr_private_key TEXT NOT NULL
-        );
-        """)
-
-
-async def m010_add_pay_link_domain(db):
-    """
-    Add domain to pay links
-    """
-    await db.execute("ALTER TABLE lnurlp.pay_links ADD COLUMN domain TEXT;")
-
-
-async def m011_add_created_at(db: Connection):
-    """
-    Add created_at to pay links
-    """
-
-    await db.execute(f"""ALTER TABLE lnurlp.pay_links ADD COLUMN
-        created_at TIMESTAMP DEFAULT {db.timestamp_column_default}""")
-    await db.execute(f"""ALTER TABLE lnurlp.pay_links ADD COLUMN
-        updated_at TIMESTAMP DEFAULT {db.timestamp_column_default}""")
-
-    now = int(time())
-    await db.execute(
-        f"""
-        UPDATE lnurlp.pay_links
-        SET created_at = {db.timestamp_placeholder('now')},
-            updated_at = {db.timestamp_placeholder('now')}
-        WHERE created_at IS NULL AND updated_at IS NULL
-        """,
-        {"now": now},
-    )
-
-
-async def m012_add_disposable(db: Connection):
-    await db.execute(
-        "ALTER TABLE lnurlp.pay_links ADD COLUMN disposable BOOLEAN DEFAULT TRUE"
-    )

models.py

@@ -1,41 +1,30 @@
-from datetime import datetime, timezone
+import json
+from sqlite3 import Row
+from typing import Dict, Optional
+from urllib.parse import ParseResult, urlparse, urlunparse
 
-from fastapi import Query
+from fastapi.param_functions import Query
-from pydantic import BaseModel, Field
+from lnurl.types import LnurlPayMetadata
-from pynostr.key import PrivateKey
+from pydantic import BaseModel
+from starlette.requests import Request
 
-from .helpers import parse_nostr_private_key
+from lnbits.lnurl import encode as lnurl_encode
-
-
-class LnurlpSettings(BaseModel):
-    nostr_private_key: str
-
-    @property
-    def private_key(self) -> PrivateKey:
-        return parse_nostr_private_key(self.nostr_private_key)
-
-    @property
-    def public_key(self) -> str:
-        return self.private_key.public_key.hex()
 
 
 class CreatePayLinkData(BaseModel):
     description: str
-    wallet: str | None = None
     min: float = Query(1, ge=0.01)
     max: float = Query(1, ge=0.01)
+    currency: str = Query(None)
     comment_chars: int = Query(0, ge=0, le=799)
-    currency: str | None = Query(None)
+    webhook_url: str = Query(None)
-    webhook_url: str | None = Query(None)
+    webhook_headers: str = Query(None)
-    webhook_headers: str | None = Query(None)
+    webhook_body: str = Query(None)
-    webhook_body: str | None = Query(None)
+    success_text: str = Query(None)
-    success_text: str | None = Query(None)
+    success_url: str = Query(None)
-    success_url: str | None = Query(None)
+    fiat_base_multiplier: int = Query(100, ge=1)
-    fiat_base_multiplier: int | None = Query(100, ge=1)
+    username: str = Query(None)
-    username: str | None = Query(None)
+    zaps: bool = Query(False)
-    zaps: bool | None = Query(False)
-    disposable: bool | None = Query(True)
-    domain: str | None = Query(None)
 
 
 class PayLink(BaseModel):
@@ -43,50 +32,56 @@ class PayLink(BaseModel):
     wallet: str
     description: str
     min: float
-    max: float
     served_meta: int
     served_pr: int
+    username: Optional[str]
+    zaps: Optional[bool]
+    domain: Optional[str]
+    webhook_url: Optional[str]
+    webhook_headers: Optional[str]
+    webhook_body: Optional[str]
+    success_text: Optional[str]
+    success_url: Optional[str]
+    currency: Optional[str]
     comment_chars: int
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    lnurl: str | None = Field(
-        default=None,
-        no_database=True,
-        deprecated=True,
-        description=(
-            "Deprecated: Instead of using this bech32 encoded string, dynamically "
-            "generate your own static link (lud17/bech32) on the client side. "
-            "Example: lnurlp://${window.location.hostname}/lnurlp/${paylink_id}"
-        ),
-    )
-    username: str | None = None
-    zaps: bool | None = None
-    webhook_url: str | None = None
-    webhook_headers: str | None = None
-    webhook_body: str | None = None
-    success_text: str | None = None
-    success_url: str | None = None
-    currency: str | None = None
-    fiat_base_multiplier: int | None = None
-    disposable: bool
-    domain: str | None = None
-
-
-class PublicPayLink(BaseModel):
-    id: str
-    username: str | None = None
-    description: str
-    min: float
     max: float
-    domain: str | None = None
+    fiat_base_multiplier: int
-    currency: str | None = None
+
-    lnurl: str | None = Field(
+    @classmethod
-        default=None,
+    def from_row(cls, row: Row) -> "PayLink":
-        no_database=True,
+        data = dict(row)
-        deprecated=True,
+        if data["currency"] and data["fiat_base_multiplier"]:
-        description=(
+            data["min"] /= data["fiat_base_multiplier"]
-            "Deprecated: Instead of using this bech32 encoded string, dynamically "
+            data["max"] /= data["fiat_base_multiplier"]
-            "generate your own static link (lud17/bech32) on the client side. "
+        return cls(**data)
-            "Example: lnurlp://${window.location.hostname}/lnurlp/${paylink_id}"
+
-        ),
+    def lnurl(self, req: Request) -> str:
-    )
+        url = req.url_for("lnurlp.api_lnurl_response", link_id=self.id)
+        return lnurl_encode(str(url))
+
+    def success_action(self, payment_hash: str) -> Optional[Dict]:
+        if self.success_url:
+            url: ParseResult = urlparse(self.success_url)
+            # qs = parse_qs(url.query)
+            # setattr(qs, "payment_hash", payment_hash)
+            # url = url._replace(query=urlencode(qs, doseq=True))
+            return {
+                "tag": "url",
+                "description": self.success_text or "~",
+                "url": urlunparse(url),
+            }
+        elif self.success_text:
+            return {"tag": "message", "message": self.success_text}
+        else:
+            return None
+
+    @property
+    def lnurlpay_metadata(self) -> LnurlPayMetadata:
+        if self.domain and self.username:
+            text = f"Payment to {self.username}"
+            identifier = f"{self.username}@{self.domain}"
+            metadata = [["text/plain", text], ["text/identifier", identifier]]
+        else:
+            metadata = [["text/plain", self.description]]
+
+        return LnurlPayMetadata(json.dumps(metadata))

nostr/bech32.py

@@ -0,0 +1,137 @@
+# Copyright (c) 2017, 2020 Pieter Wuille
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Reference implementation for Bech32/Bech32m and segwit addresses."""
+
+
+from enum import Enum
+
+class Encoding(Enum):
+    """Enumeration type to list the various supported encodings."""
+    BECH32 = 1
+    BECH32M = 2
+
+CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+BECH32M_CONST = 0x2bc830a3
+
+def bech32_polymod(values):
+    """Internal function that computes the Bech32 checksum."""
+    generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
+    chk = 1
+    for value in values:
+        top = chk >> 25
+        chk = (chk & 0x1ffffff) << 5 ^ value
+        for i in range(5):
+            chk ^= generator[i] if ((top >> i) & 1) else 0
+    return chk
+
+
+def bech32_hrp_expand(hrp):
+    """Expand the HRP into values for checksum computation."""
+    return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 31 for x in hrp]
+
+
+def bech32_verify_checksum(hrp, data):
+    """Verify a checksum given HRP and converted data characters."""
+    const = bech32_polymod(bech32_hrp_expand(hrp) + data)
+    if const == 1:
+        return Encoding.BECH32
+    if const == BECH32M_CONST:
+        return Encoding.BECH32M
+    return None
+
+def bech32_create_checksum(hrp, data, spec):
+    """Compute the checksum values given HRP and data."""
+    values = bech32_hrp_expand(hrp) + data
+    const = BECH32M_CONST if spec == Encoding.BECH32M else 1
+    polymod = bech32_polymod(values + [0, 0, 0, 0, 0, 0]) ^ const
+    return [(polymod >> 5 * (5 - i)) & 31 for i in range(6)]
+
+
+def bech32_encode(hrp, data, spec):
+    """Compute a Bech32 string given HRP and data values."""
+    combined = data + bech32_create_checksum(hrp, data, spec)
+    return hrp + '1' + ''.join([CHARSET[d] for d in combined])
+
+def bech32_decode(bech):
+    """Validate a Bech32/Bech32m string, and determine HRP and data."""
+    if ((any(ord(x) < 33 or ord(x) > 126 for x in bech)) or
+            (bech.lower() != bech and bech.upper() != bech)):
+        return (None, None, None)
+    bech = bech.lower()
+    pos = bech.rfind('1')
+    if pos < 1 or pos + 7 > len(bech) or len(bech) > 90:
+        return (None, None, None)
+    if not all(x in CHARSET for x in bech[pos+1:]):
+        return (None, None, None)
+    hrp = bech[:pos]
+    data = [CHARSET.find(x) for x in bech[pos+1:]]
+    spec = bech32_verify_checksum(hrp, data)
+    if spec is None:
+        return (None, None, None)
+    return (hrp, data[:-6], spec)
+
+def convertbits(data, frombits, tobits, pad=True):
+    """General power-of-2 base conversion."""
+    acc = 0
+    bits = 0
+    ret = []
+    maxv = (1 << tobits) - 1
+    max_acc = (1 << (frombits + tobits - 1)) - 1
+    for value in data:
+        if value < 0 or (value >> frombits):
+            return None
+        acc = ((acc << frombits) | value) & max_acc
+        bits += frombits
+        while bits >= tobits:
+            bits -= tobits
+            ret.append((acc >> bits) & maxv)
+    if pad:
+        if bits:
+            ret.append((acc << (tobits - bits)) & maxv)
+    elif bits >= frombits or ((acc << (tobits - bits)) & maxv):
+        return None
+    return ret
+
+
+def decode(hrp, addr):
+    """Decode a segwit address."""
+    hrpgot, data, spec = bech32_decode(addr)
+    if hrpgot != hrp:
+        return (None, None)
+    decoded = convertbits(data[1:], 5, 8, False)
+    if decoded is None or len(decoded) < 2 or len(decoded) > 40:
+        return (None, None)
+    if data[0] > 16:
+        return (None, None)
+    if data[0] == 0 and len(decoded) != 20 and len(decoded) != 32:
+        return (None, None)
+    if data[0] == 0 and spec != Encoding.BECH32 or data[0] != 0 and spec != Encoding.BECH32M:
+        return (None, None)
+    return (data[0], decoded)
+
+
+def encode(hrp, witver, witprog):
+    """Encode a segwit address."""
+    spec = Encoding.BECH32 if witver == 0 else Encoding.BECH32M
+    ret = bech32_encode(hrp, [witver] + convertbits(witprog, 8, 5), spec)
+    if decode(hrp, ret) == (None, None):
+        return None
+    return ret

nostr/event.py

@@ -0,0 +1,126 @@
+import time
+import json
+from dataclasses import dataclass, field
+from enum import IntEnum
+from typing import List
+from secp256k1 import PublicKey
+from hashlib import sha256
+
+from .message_type import ClientMessageType
+
+
+class EventKind(IntEnum):
+    SET_METADATA = 0
+    TEXT_NOTE = 1
+    RECOMMEND_RELAY = 2
+    CONTACTS = 3
+    ENCRYPTED_DIRECT_MESSAGE = 4
+    DELETE = 5
+
+
+@dataclass
+class Event:
+    content: str = None
+    public_key: str = None
+    created_at: int = None
+    kind: int = EventKind.TEXT_NOTE
+    tags: List[List[str]] = field(
+        default_factory=list
+    )  # Dataclasses require special handling when the default value is a mutable type
+    signature: str = None
+
+    def __post_init__(self):
+        if self.content is not None and not isinstance(self.content, str):
+            # DMs initialize content to None but all other kinds should pass in a str
+            raise TypeError("Argument 'content' must be of type str")
+
+        if self.created_at is None:
+            self.created_at = int(time.time())
+
+    @staticmethod
+    def serialize(
+        public_key: str, created_at: int, kind: int, tags: List[List[str]], content: str
+    ) -> bytes:
+        data = [0, public_key, created_at, kind, tags, content]
+        data_str = json.dumps(data, separators=(",", ":"), ensure_ascii=False)
+        return data_str.encode()
+
+    @staticmethod
+    def compute_id(
+        public_key: str, created_at: int, kind: int, tags: List[List[str]], content: str
+    ):
+        return sha256(
+            Event.serialize(public_key, created_at, kind, tags, content)
+        ).hexdigest()
+
+    @property
+    def id(self) -> str:
+        # Always recompute the id to reflect the up-to-date state of the Event
+        return Event.compute_id(
+            self.public_key, self.created_at, self.kind, self.tags, self.content
+        )
+
+    def add_pubkey_ref(self, pubkey: str):
+        """Adds a reference to a pubkey as a 'p' tag"""
+        self.tags.append(["p", pubkey])
+
+    def add_event_ref(self, event_id: str):
+        """Adds a reference to an event_id as an 'e' tag"""
+        self.tags.append(["e", event_id])
+
+    def verify(self) -> bool:
+        pub_key = PublicKey(
+            bytes.fromhex("02" + self.public_key), True
+        )  # add 02 for schnorr (bip340)
+        return pub_key.schnorr_verify(
+            bytes.fromhex(self.id), bytes.fromhex(self.signature), None, raw=True
+        )
+
+    def to_message(self) -> str:
+        return json.dumps(
+            [
+                ClientMessageType.EVENT,
+                {
+                    "id": self.id,
+                    "pubkey": self.public_key,
+                    "created_at": self.created_at,
+                    "kind": self.kind,
+                    "tags": self.tags,
+                    "content": self.content,
+                    "sig": self.signature,
+                },
+            ]
+        )
+
+
+@dataclass
+class EncryptedDirectMessage(Event):
+    recipient_pubkey: str = None
+    cleartext_content: str = None
+    reference_event_id: str = None
+
+    def __post_init__(self):
+        if self.content is not None:
+            self.cleartext_content = self.content
+            self.content = None
+
+        if self.recipient_pubkey is None:
+            raise Exception("Must specify a recipient_pubkey.")
+
+        self.kind = EventKind.ENCRYPTED_DIRECT_MESSAGE
+        super().__post_init__()
+
+        # Must specify the DM recipient's pubkey in a 'p' tag
+        self.add_pubkey_ref(self.recipient_pubkey)
+
+        # Optionally specify a reference event (DM) this is a reply to
+        if self.reference_event_id is not None:
+            self.add_event_ref(self.reference_event_id)
+
+    @property
+    def id(self) -> str:
+        if self.content is None:
+            raise Exception(
+                "EncryptedDirectMessage `id` is undefined until its message is encrypted and stored in the `content` field"
+            )
+        return super().id

nostr/key.py

@@ -0,0 +1,147 @@
+import secrets
+import base64
+import secp256k1
+from cffi import FFI
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives import padding
+from hashlib import sha256
+
+from .event import EncryptedDirectMessage, Event, EventKind
+from . import bech32
+
+
+class PublicKey:
+    def __init__(self, raw_bytes: bytes) -> None:
+        self.raw_bytes = raw_bytes
+
+    def bech32(self) -> str:
+        converted_bits = bech32.convertbits(self.raw_bytes, 8, 5)
+        return bech32.bech32_encode("npub", converted_bits, bech32.Encoding.BECH32)
+
+    def hex(self) -> str:
+        return self.raw_bytes.hex()
+
+    def verify_signed_message_hash(self, hash: str, sig: str) -> bool:
+        pk = secp256k1.PublicKey(b"\x02" + self.raw_bytes, True)
+        return pk.schnorr_verify(bytes.fromhex(hash), bytes.fromhex(sig), None, True)
+
+    @classmethod
+    def from_npub(cls, npub: str):
+        """Load a PublicKey from its bech32/npub form"""
+        hrp, data, spec = bech32.bech32_decode(npub)
+        raw_public_key = bech32.convertbits(data, 5, 8)[:-1]
+        return cls(bytes(raw_public_key))
+
+
+class PrivateKey:
+    def __init__(self, raw_secret: bytes = None) -> None:
+        if not raw_secret is None:
+            self.raw_secret = raw_secret
+        else:
+            self.raw_secret = secrets.token_bytes(32)
+
+        sk = secp256k1.PrivateKey(self.raw_secret)
+        self.public_key = PublicKey(sk.pubkey.serialize()[1:])
+
+    @classmethod
+    def from_nsec(cls, nsec: str):
+        """Load a PrivateKey from its bech32/nsec form"""
+        hrp, data, spec = bech32.bech32_decode(nsec)
+        raw_secret = bech32.convertbits(data, 5, 8)[:-1]
+        return cls(bytes(raw_secret))
+
+    def bech32(self) -> str:
+        converted_bits = bech32.convertbits(self.raw_secret, 8, 5)
+        return bech32.bech32_encode("nsec", converted_bits, bech32.Encoding.BECH32)
+
+    def hex(self) -> str:
+        return self.raw_secret.hex()
+
+    def tweak_add(self, scalar: bytes) -> bytes:
+        sk = secp256k1.PrivateKey(self.raw_secret)
+        return sk.tweak_add(scalar)
+
+    def compute_shared_secret(self, public_key_hex: str) -> bytes:
+        pk = secp256k1.PublicKey(bytes.fromhex("02" + public_key_hex), True)
+        return pk.ecdh(self.raw_secret, hashfn=copy_x)
+
+    def encrypt_message(self, message: str, public_key_hex: str) -> str:
+        padder = padding.PKCS7(128).padder()
+        padded_data = padder.update(message.encode()) + padder.finalize()
+
+        iv = secrets.token_bytes(16)
+        cipher = Cipher(
+            algorithms.AES(self.compute_shared_secret(public_key_hex)), modes.CBC(iv)
+        )
+
+        encryptor = cipher.encryptor()
+        encrypted_message = encryptor.update(padded_data) + encryptor.finalize()
+
+        return f"{base64.b64encode(encrypted_message).decode()}?iv={base64.b64encode(iv).decode()}"
+
+    def encrypt_dm(self, dm: EncryptedDirectMessage) -> None:
+        dm.content = self.encrypt_message(
+            message=dm.cleartext_content, public_key_hex=dm.recipient_pubkey
+        )
+
+    def decrypt_message(self, encoded_message: str, public_key_hex: str) -> str:
+        encoded_data = encoded_message.split("?iv=")
+        encoded_content, encoded_iv = encoded_data[0], encoded_data[1]
+
+        iv = base64.b64decode(encoded_iv)
+        cipher = Cipher(
+            algorithms.AES(self.compute_shared_secret(public_key_hex)), modes.CBC(iv)
+        )
+        encrypted_content = base64.b64decode(encoded_content)
+
+        decryptor = cipher.decryptor()
+        decrypted_message = decryptor.update(encrypted_content) + decryptor.finalize()
+
+        unpadder = padding.PKCS7(128).unpadder()
+        unpadded_data = unpadder.update(decrypted_message) + unpadder.finalize()
+
+        return unpadded_data.decode()
+
+    def sign_message_hash(self, hash: bytes) -> str:
+        sk = secp256k1.PrivateKey(self.raw_secret)
+        sig = sk.schnorr_sign(hash, None, raw=True)
+        return sig.hex()
+
+    def sign_event(self, event: Event) -> None:
+        if event.kind == EventKind.ENCRYPTED_DIRECT_MESSAGE and event.content is None:
+            self.encrypt_dm(event)
+        if event.public_key is None:
+            event.public_key = self.public_key.hex()
+        event.signature = self.sign_message_hash(bytes.fromhex(event.id))
+
+    def __eq__(self, other):
+        return self.raw_secret == other.raw_secret
+
+
+def mine_vanity_key(prefix: str = None, suffix: str = None) -> PrivateKey:
+    if prefix is None and suffix is None:
+        raise ValueError("Expected at least one of 'prefix' or 'suffix' arguments")
+
+    while True:
+        sk = PrivateKey()
+        if (
+            prefix is not None
+            and not sk.public_key.bech32()[5 : 5 + len(prefix)] == prefix
+        ):
+            continue
+        if suffix is not None and not sk.public_key.bech32()[-len(suffix) :] == suffix:
+            continue
+        break
+
+    return sk
+
+
+ffi = FFI()
+
+
+@ffi.callback(
+    "int (unsigned char *, const unsigned char *, const unsigned char *, void *)"
+)
+def copy_x(output, x32, y32, data):
+    ffi.memmove(output, x32, 32)
+    return 1

nostr/message_type.py

@@ -0,0 +1,15 @@
+class ClientMessageType:
+    EVENT = "EVENT"
+    REQUEST = "REQ"
+    CLOSE = "CLOSE"
+
+class RelayMessageType:
+    EVENT = "EVENT"
+    NOTICE = "NOTICE"
+    END_OF_STORED_EVENTS = "EOSE"
+
+    @staticmethod
+    def is_valid(type: str) -> bool:
+        if type == RelayMessageType.EVENT or type == RelayMessageType.NOTICE or type == RelayMessageType.END_OF_STORED_EVENTS:
+            return True
+        return False

package-lock.json

@@ -1,62 +0,0 @@
-{
-  "name": "lnurlp",
-  "version": "1.0.0",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "lnurlp",
-      "version": "1.0.0",
-      "license": "ISC",
-      "dependencies": {
-        "prettier": "^3.7.4",
-        "pyright": "^1.1.407"
-      }
-    },
-    "node_modules/fsevents": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
-      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
-      "hasInstallScript": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
-      }
-    },
-    "node_modules/prettier": {
-      "version": "3.7.4",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.7.4.tgz",
-      "integrity": "sha512-v6UNi1+3hSlVvv8fSaoUbggEM5VErKmmpGA7Pl3HF8V6uKY7rvClBOJlH6yNwQtfTueNkGVpOv/mtWL9L4bgRA==",
-      "license": "MIT",
-      "bin": {
-        "prettier": "bin/prettier.cjs"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/prettier/prettier?sponsor=1"
-      }
-    },
-    "node_modules/pyright": {
-      "version": "1.1.407",
-      "resolved": "https://registry.npmjs.org/pyright/-/pyright-1.1.407.tgz",
-      "integrity": "sha512-zU+peTFEVUdokNQyUBhGQYt+NWI/3aiNlvBbDBSsn5Ti334XElFUs+GDjQzCbchYfkT+DvMAT3OkMcV4CuEfDg==",
-      "license": "MIT",
-      "bin": {
-        "pyright": "index.js",
-        "pyright-langserver": "langserver.index.js"
-      },
-      "engines": {
-        "node": ">=14.0.0"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.3"
-      }
-    }
-  }
-}

package.json

@@ -1,15 +0,0 @@
-{
-  "name": "lnurlp",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "prettier": "^3.7.4",
-    "pyright": "^1.1.407"
-  }
-}

pyproject.toml

@@ -1,97 +0,0 @@
-[project]
-name = "lnbits-lnurlp"
-version = "0.0.0"
-requires-python = ">=3.10,<3.13"
-description = "LNbits, free and open-source Lightning wallet and accounts system."
-authors = [{ name = "Alan Bits", email = "alan@lnbits.com" }]
-urls = { Homepage = "https://lnbits.com", Repository = "https://github.com/lnbits/lnbits" }
-dependencies = ["lnbits>1"]
-
-[tool.poetry]
-package-mode = false
-
-[dependency-groups]
-dev = [
-    "black>=24.3.0",
-    "pytest-asyncio>=0.21.0",
-    "pytest>=7.3.2",
-    "mypy==1.17.1",
-    "pre-commit>=3.2.2",
-    "ruff>=0.3.2",
-    "types-cffi>=1.16.0.20240331",
-]
-
-[tool.mypy]
-# exclude = "(nostr/*)"
-plugins = "pydantic.mypy"
-
-[tool.pydantic-mypy]
-init_forbid_extra = true
-init_typed = true
-warn_required_dynamic_aliases = true
-warn_untyped_fields = true
-
-[[tool.mypy.overrides]]
-module = [
-  "lnbits.*",
-  "pynostr.*",
-]
-ignore_missing_imports = "True"
-
-[tool.pytest.ini_options]
-log_cli = false
-testpaths = [
-  "tests"
-]
-
-[tool.black]
-line-length = 88
-
-[tool.ruff]
-# Same as Black. + 10% rule of black
-line-length = 88
-# exclude = [
-#     "nostr",
-# ]
-
-[tool.ruff.lint]
-# Enable:
-# F - pyflakes
-# E - pycodestyle errors
-# W - pycodestyle warnings
-# I - isort
-# A - flake8-builtins
-# C - mccabe
-# N - naming
-# UP - pyupgrade
-# RUF - ruff
-# B - bugbear
-select = ["F", "E", "W", "I", "A", "C", "N", "UP", "RUF", "B"]
-ignore = ["C901"]
-
-# Allow autofix for all enabled rules (when `--fix`) is provided.
-fixable = ["ALL"]
-unfixable = []
-
-# Allow unused variables when underscore-prefixed.
-dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
-
-# needed for pydantic
-[tool.ruff.lint.pep8-naming]
-classmethod-decorators = [
-    "root_validator",
-]
-
-# Ignore unused imports in __init__.py files.
-# [tool.ruff.lint.extend-per-file-ignores]
-# "__init__.py" = ["F401", "F403"]
-
-# [tool.ruff.lint.mccabe]
-# max-complexity = 10
-
-[tool.ruff.lint.flake8-bugbear]
-# Allow default arguments like, e.g., `data: List[str] = fastapi.Query(None)`.
-extend-immutable-calls = [
-    "fastapi.Depends",
-    "fastapi.Query",
-]

services.py

@@ -0,0 +1,9 @@
+import re
+
+
+async def check_lnaddress_format(username: str) -> bool:
+    # check username complies with lnaddress specification
+    if not re.match("^[a-z0-9-_.]{3,15}$", username):
+        assert False, "Only letters a-z0-9-_. allowed, min 3 and max 15 characters!"
+        return
+    return True

static/display.js

@@ -1,27 +0,0 @@
-window.PageLnurlpPublic = {
-  template: '#page-lnurlp-public',
-  data() {
-    return {
-      url: '',
-      payLink: null
-    }
-  },
-  methods: {
-    setUrl(link_id, domain) {
-      this.url = `https://${domain || window.location.host}/lnurlp/${link_id}`
-    },
-    getPayLink() {
-      this.api
-        .request('GET', `/lnurlp/api/v1/links/public/${this.$route.params.id}`)
-        .then(res => {
-          this.payLink = res.data
-          this.setUrl(this.payLink.id, this.payLink.domain)
-        })
-        .catch(this.utils.notifyApiError)
-    }
-  },
-  created() {
-    this.setUrl(this.$route.params.id)
-    this.getPayLink()
-  }
-}

static/display.vue

@@ -1,67 +0,0 @@
-<template id="page-lnurlp-public">
-  <div class="row q-col-gutter-md justify-center">
-    <div class="col-12 col-sm-6 col-md-5 col-lg-4">
-      <q-card class="q-pa-lg">
-        <q-card-section class="q-pa-none">
-          <div class="text-center">
-            <lnbits-qrcode-lnurl :url="url" :nfc="true"></lnbits-qrcode-lnurl>
-          </div>
-        </q-card-section>
-      </q-card>
-    </div>
-    <div class="col-12 col-sm-6 col-md-5 col-lg-4 q-gutter-y-md">
-      <q-card>
-        <q-card-section>
-          <h6 class="text-subtitle1 q-mb-sm q-mt-none">
-            LNbits LNURL-pay link
-          </h6>
-          <p class="q-my-none">
-            Use an LNURL compatible bitcoin wallet to pay.
-          </p>
-        </q-card-section>
-        <q-card-section class="q-pa-none">
-          <q-separator></q-separator>
-          <q-list>
-            <q-expansion-item
-              group="extras"
-              icon="info"
-              label="Powered by LNURL"
-            >
-              <q-card>
-                <q-card-section>
-                  <p>
-                    LNURL is a range of lightning-network standards that allow
-                    us to use lightning-network differently. An LNURL-pay is a
-                    link that wallets use to fetch an invoice from a server
-                    on-demand. The link or QR code is fixed, but each time it is
-                    read by a compatible wallet a new QR code is issued by the
-                    service. It can be used to activate machines without them
-                    having to maintain an electronic screen to generate and show
-                    invoices locally, or to sell any predefined good or service
-                    automatically.
-                  </p>
-                  <p>
-                    Exploring LNURL and finding use cases, is really helping
-                    inform lightning protocol development, rather than the
-                    protocol dictating how lightning-network should be engaged
-                    with.
-                  </p>
-                  <small
-                    >Check
-                    <a
-                      class="text-secondary"
-                      href="https://github.com/fiatjaf/awesome-lnurl"
-                      target="_blank"
-                      >Awesome LNURL</a
-                    >
-                    for further information.</small
-                  >
-                </q-card-section>
-              </q-card>
-            </q-expansion-item>
-          </q-list>
-        </q-card-section>
-      </q-card>
-    </div>
-  </div>
-</template>

static/index.vue

@@ -1,686 +0,0 @@
-<template id="page-lnurlp">
-  <div class="row q-col-gutter-md">
-    <div class="col-12 col-md-7 q-gutter-y-md">
-      <q-card>
-        <q-card-section>
-          <q-btn unelevated color="primary" @click="formDialog.show = true"
-            >New pay link</q-btn
-          >
-          <lnbits-extension-settings-btn-dialog
-            v-if="g.user.admin"
-            :endpoint="endpoint"
-            :options="settings"
-          />
-        </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">Pay links</h5>
-            </div>
-          </div>
-          <q-table
-            dense
-            flat
-            :rows="payLinks"
-            :columns="payLinksTable.columns"
-            row-key="id"
-            v-model:pagination="payLinksTable.pagination"
-          >
-            <template v-slot:header="props">
-              <q-tr class="text-left" :props="props">
-                <q-th auto-width></q-th>
-                <q-th v-for="col in props.cols" :key="col.name" :props="props">
-                  <span v-text="col.label"></span>
-                </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="launch"
-                    :color="$q.dark.isActive ? 'grey-7' : 'grey-5'"
-                    type="a"
-                    :href="props.row.pay_url"
-                    target="_blank"
-                    class="q-ml-sm"
-                    ><q-tooltip>Shareable Page</q-tooltip></q-btn
-                  >
-                  <q-btn
-                    dense
-                    size="xs"
-                    icon="visibility"
-                    :color="$q.dark.isActive ? 'grey-7' : 'grey-5'"
-                    class="q-ml-sm"
-                    @click="openQrCodeDialog(props.row.id)"
-                    ><q-tooltip>View Link</q-tooltip></q-btn
-                  >
-                  <q-btn
-                    flat
-                    dense
-                    size="xs"
-                    @click="openUpdateDialog(props.row.id)"
-                    icon="edit"
-                    color="light-blue"
-                    class="q-ml-sm"
-                  >
-                    <q-tooltip>Edit</q-tooltip>
-                  </q-btn>
-                  <q-btn
-                    flat
-                    dense
-                    size="xs"
-                    @click="deletePayLink(props.row.id)"
-                    icon="cancel"
-                    color="pink"
-                    class="q-ml-sm"
-                    ><q-tooltip>Delete</q-tooltip></q-btn
-                  >
-                </q-td>
-                <q-td
-                  v-for="col in props.cols"
-                  :key="col.name"
-                  :props="props"
-                  v-text="col.value"
-                ></q-td>
-                <q-td>
-                  <q-icon v-if="props.row.webhook_url" size="14px" name="http">
-                    <q-tooltip
-                      >Webhook to <span v-text="props.row.webhook_url"></span
-                    ></q-tooltip>
-                  </q-icon>
-                  <q-icon
-                    v-if="props.row.success_text || props.row.success_url"
-                    size="14px"
-                    name="call_to_action"
-                  >
-                    <q-tooltip>
-                      On success, show message '<span
-                        v-text="props.row.success_text"
-                      ></span
-                      >'
-                      <span v-if="props.row.success_url"
-                        >and URL '<span v-text="props.row.success_url"></span
-                        >'</span
-                      >
-                    </q-tooltip>
-                  </q-icon>
-                  <q-icon
-                    v-if="props.row.comment_chars > 0"
-                    size="14px"
-                    name="insert_comment"
-                  >
-                    <q-tooltip>
-                      <span v-text="props.row.comment_chars"></span>-char
-                      comment allowed
-                    </q-tooltip>
-                  </q-icon>
-                </q-td>
-              </q-tr>
-            </template>
-          </q-table>
-        </q-card-section>
-      </q-card>
-    </div>
-
-    <div class="col-12 col-md-5 q-gutter-y-md">
-      <q-card>
-        <q-card-section>
-          <h6 class="text-subtitle1 q-my-none">LNURL-pay extension</h6>
-        </q-card-section>
-        <q-card-section class="q-pa-none">
-          <q-separator></q-separator>
-          <q-list>
-            <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#/lnurlp"
-              ></q-btn>
-              <q-expansion-item
-                group="api"
-                dense
-                expand-separator
-                label="List pay links"
-              >
-                <q-card>
-                  <q-card-section>
-                    <code
-                      ><span class="text-blue">GET</span>
-                      /lnurlp/api/v1/links</code
-                    >
-                    <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
-                    <code>{"X-Api-Key": &lt;invoice_key&gt;}</code><br />
-                    <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 200 OK (application/json)
-                    </h5>
-                    <code>[&lt;pay_link_object&gt;, ...]</code>
-                    <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
-                    <code
-                      >curl -X GET <span v-text="baseUrl"></span> -H "X-Api-Key:
-                      <span v-text="g.user.wallets[0].inkey"></span>"
-                    </code>
-                  </q-card-section>
-                </q-card>
-              </q-expansion-item>
-              <q-expansion-item
-                group="api"
-                dense
-                expand-separator
-                label="Get a pay link"
-              >
-                <q-card>
-                  <q-card-section>
-                    <code
-                      ><span class="text-blue">GET</span>
-                      /lnurlp/api/v1/links/&lt;pay_id&gt;</code
-                    >
-                    <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
-                    <code>{"X-Api-Key": &lt;invoice_key&gt;}</code><br />
-                    <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>{"lnurl": &lt;string&gt;}</code>
-                    <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
-                    <code
-                      >curl -X GET
-                      <span v-text="baseUrl + '/&lt;pay_id&gt;'"></span>
-                      -H "X-Api-Key:
-                      <span v-text="g.user.wallets[0].inkey"></span>"
-                    </code>
-                  </q-card-section>
-                </q-card>
-              </q-expansion-item>
-              <q-expansion-item
-                group="api"
-                dense
-                expand-separator
-                label="Create a pay link"
-              >
-                <q-btn
-                  flat
-                  label="Swagger API"
-                  type="a"
-                  href="../docs#/lnurlp"
-                ></q-btn>
-                <q-card>
-                  <q-card-section>
-                    <code
-                      ><span class="text-green">POST</span>
-                      /lnurlp/api/v1/links</code
-                    >
-                    <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
-                    <code>{"X-Api-Key": &lt;admin_key&gt;}</code><br />
-                    <h5 class="text-caption q-mt-sm q-mb-none">
-                      Body (application/json)
-                    </h5>
-                    <code
-                      >{"description": &lt;string&gt; "amount": &lt;integer&gt;
-                      "max": &lt;integer&gt; "min": &lt;integer&gt;
-                      "comment_chars": &lt;integer&gt; "username":
-                      &lt;string&gt; }</code
-                    >
-                    <h5 class="text-caption q-mt-sm q-mb-none">
-                      Returns 201 CREATED (application/json)
-                    </h5>
-                    <code>{"lnurl": &lt;string&gt;}</code>
-                    <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
-                    <code
-                      >curl -X POST <span v-text="baseUrl"></span> -d
-                      '{"description": &lt;string&gt;, "amount":
-                      &lt;integer&gt;, "max": &lt;integer&gt;, "min":
-                      &lt;integer&gt;, "comment_chars": &lt;integer&gt;}' -H
-                      "Content-type: application/json" -H "X-Api-Key:
-                      <span v-text="g.user.wallets[0].adminkey"></span>"
-                    </code>
-                  </q-card-section>
-                </q-card>
-              </q-expansion-item>
-              <q-expansion-item
-                group="api"
-                dense
-                expand-separator
-                label="Update a pay link"
-              >
-                <q-card>
-                  <q-card-section>
-                    <code
-                      ><span class="text-green">PUT</span>
-                      /lnurlp/api/v1/links/&lt;pay_id&gt;</code
-                    >
-                    <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
-                    <code>{"X-Api-Key": &lt;admin_key&gt;}</code><br />
-                    <h5 class="text-caption q-mt-sm q-mb-none">
-                      Body (application/json)
-                    </h5>
-                    <code
-                      >{"description": &lt;string&gt;, "amount":
-                      &lt;integer&gt;}</code
-                    >
-                    <h5 class="text-caption q-mt-sm q-mb-none">
-                      Returns 200 OK (application/json)
-                    </h5>
-                    <code>{"lnurl": &lt;string&gt;}</code>
-                    <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
-                    <code
-                      >curl -X PUT
-                      <span v-text="baseUrl + '/&lt;pay_id&gt;'"></span>
-                      -d '{"description": &lt;string&gt;, "amount":
-                      &lt;integer&gt;}' -H "Content-type: application/json" -H
-                      "X-Api-Key:
-                      <span v-text="g.user.wallets[0].adminkey"></span>"
-                    </code>
-                  </q-card-section>
-                </q-card>
-              </q-expansion-item>
-              <q-expansion-item
-                group="api"
-                dense
-                expand-separator
-                label="Delete a pay link"
-                class="q-pb-md"
-              >
-                <q-card>
-                  <q-card-section>
-                    <code
-                      ><span class="text-pink">DELETE</span>
-                      /lnurlp/api/v1/links/&lt;pay_id&gt;</code
-                    >
-                    <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
-                    <code>{"X-Api-Key": &lt;admin_key&gt;}</code><br />
-                    <h5 class="text-caption q-mt-sm q-mb-none">
-                      Returns 204 NO CONTENT
-                    </h5>
-                    <code></code>
-                    <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
-                    <code
-                      >curl -X DELETE
-                      <span v-text="baseUrl + '/&lt;pay_id&gt;'"></span>
-                      -H "X-Api-Key:
-                      <span v-text="g.user.wallets[0].adminkey"></span>"
-                    </code>
-                  </q-card-section>
-                </q-card>
-              </q-expansion-item>
-            </q-expansion-item>
-            <q-separator></q-separator>
-            <q-expansion-item
-              group="extras"
-              icon="info"
-              label="Powered by LNURL"
-            >
-              <q-card>
-                <q-card-section>
-                  <p>
-                    <b>WARNING: LNURL must be used over https or TOR</b><br />
-                    LNURL is a range of lightning-network standards that allow
-                    us to use lightning-network differently. An LNURL-pay is a
-                    link that wallets use to fetch an invoice from a server
-                    on-demand. The link or QR code is fixed, but each time it is
-                    read by a compatible wallet a new QR code is issued by the
-                    service. It can be used to activate machines without them
-                    having to maintain an electronic screen to generate and show
-                    invoices locally, or to sell any predefined good or service
-                    automatically.
-                  </p>
-                  <p>
-                    Exploring LNURL and finding use cases, is really helping
-                    inform lightning protocol development, rather than the
-                    protocol dictating how lightning-network should be engaged
-                    with.
-                  </p>
-                  <small
-                    >Check
-                    <a
-                      class="text-secondary"
-                      href="https://github.com/fiatjaf/awesome-lnurl"
-                      target="_blank"
-                      >Awesome LNURL</a
-                    >
-                    for further information.</small
-                  >
-                </q-card-section>
-              </q-card>
-            </q-expansion-item>
-          </q-list>
-        </q-card-section>
-      </q-card>
-    </div>
-
-    <q-dialog v-model="formDialog.show" @hide="closeFormDialog">
-      <q-card class="q-pa-lg q-pt-xl lnbits__dialog-card">
-        <q-form @submit="sendFormData" class="q-gutter-md">
-          <q-select
-            filled
-            dense
-            emit-value
-            v-model="formDialog.data.wallet"
-            :options="g.user.walletOptions"
-            label="Wallet *"
-          >
-          </q-select>
-          <q-input
-            filled
-            dense
-            v-model.trim="formDialog.data.description"
-            type="text"
-            label="Item description *"
-          >
-          </q-input>
-          <div class="row">
-            <div class="col">
-              <q-input
-                filled
-                dense
-                v-model.trim="formDialog.data.username"
-                type="text"
-                label="Lightning Address"
-                @input="
-                  formDialog.data.username =
-                    formDialog.data.username.toLowerCase()
-                "
-              />
-            </div>
-            <div class="col" style="flex: 0 0 auto; margin-top: 10px">
-              <span class="label"> &nbsp;@&nbsp; </span>
-            </div>
-            <div class="col">
-              <q-input
-                filled
-                dense
-                v-model.trim="formDialog.data.domain"
-                type="text"
-                :label="domain"
-              />
-            </div>
-          </div>
-          <div class="row q-col-gutter-sm q-mx-sm">
-            <q-input
-              filled
-              dense
-              v-model.number="formDialog.data.min"
-              type="number"
-              :step="
-                formDialog.data.currency &&
-                formDialog.data.currency !== 'satoshis'
-                  ? '0.01'
-                  : '1'
-              "
-              :label="formDialog.fixedAmount ? 'Amount *' : 'Min *'"
-              :hint="
-                formDialog.data.currency &&
-                fiatRates[formDialog.data.currency] &&
-                formDialog.data.min
-                  ? `approx. ${parseInt(Math.round(formDialog.data.min * fiatRates[formDialog.data.currency]))} sat`
-                  : ''
-              "
-            ></q-input>
-            <q-input
-              v-if="!formDialog.fixedAmount"
-              filled
-              dense
-              v-model.number="formDialog.data.max"
-              type="number"
-              :step="
-                formDialog.data.currency &&
-                formDialog.data.currency !== 'satoshis'
-                  ? '0.01'
-                  : '1'
-              "
-              label="Max *"
-              :hint="
-                formDialog.data.currency &&
-                fiatRates[formDialog.data.currency] &&
-                formDialog.data.max
-                  ? `approx. ${parseInt(Math.round(formDialog.data.max * fiatRates[formDialog.data.currency]))} sat`
-                  : ''
-              "
-            ></q-input>
-          </div>
-          <div class="row q-col-gutter-sm">
-            <div class="col">
-              <q-checkbox
-                dense
-                v-model="formDialog.fixedAmount"
-                label="Fixed amount"
-              />
-            </div>
-            <div class="col">
-              <q-select
-                dense
-                :options="g.allowedCurrencies || g.currencies"
-                v-model="formDialog.data.currency"
-                :display-value="formDialog.data.currency || 'satoshis'"
-                label="Currency"
-                :hint="
-                  'Converted to satoshis at each payment. ' +
-                  (formDialog.data.currency &&
-                  fiatRates[formDialog.data.currency]
-                    ? `Currently 1 ${formDialog.data.currency} = ${fiatRates[formDialog.data.currency]} sat`
-                    : '')
-                "
-                @input="updateFiatRate"
-              />
-            </div>
-          </div>
-          <q-expansion-item
-            group="advanced"
-            icon="settings"
-            label="Advanced options"
-          >
-            <q-card>
-              <q-card-section>
-                <h5 class="text-caption q-mt-sm q-mb-none">
-                  LUD-11: Disposable and storeable payRequests.
-                </h5>
-                <div class="row">
-                  <div class="col-12">
-                    <q-checkbox
-                      dense
-                      :toggle-indeterminate="false"
-                      v-model="formDialog.data.disposable"
-                      label="If enabled, the LNURL will not be stored (default)."
-                    />
-                  </div>
-                </div>
-                <h5 class="text-caption q-mt-sm q-mb-none">LNURL</h5>
-                <div class="row">
-                  <div class="col-12">
-                    <q-input
-                      filled
-                      dense
-                      v-model.number="formDialog.data.comment_chars"
-                      type="number"
-                      label="Comment maximum characters"
-                      hint="Allow the payer to attach a comment."
-                    >
-                    </q-input>
-                  </div>
-                </div>
-                <div class="row">
-                  <div class="col-12">
-                    <q-input
-                      filled
-                      dense
-                      v-model="formDialog.data.webhook_url"
-                      type="text"
-                      label="Webhook URL (optional)"
-                      hint="A URL to be called whenever this link receives a payment."
-                    ></q-input>
-                  </div>
-                </div>
-                <div class="row" v-if="formDialog.data.webhook_url">
-                  <div class="col-12">
-                    <q-input
-                      filled
-                      dense
-                      v-model="formDialog.data.webhook_headers"
-                      type="text"
-                      label="Webhook headers (optional)"
-                      hint="Custom data as JSON string, send headers along with the webhook."
-                    ></q-input>
-                  </div>
-                  <div class="col-12">
-                    <q-input
-                      filled
-                      dense
-                      v-model="formDialog.data.webhook_body"
-                      type="text"
-                      label="Webhook custom data (optional)"
-                      hint="Custom data as JSON string, will get posted along with webhook 'body' field."
-                    ></q-input>
-                  </div>
-                </div>
-                <div class="row">
-                  <div class="col-12">
-                    <q-input
-                      filled
-                      dense
-                      v-model="formDialog.data.success_text"
-                      type="text"
-                      label="Success message (optional)"
-                      hint="Will be shown to the user in his wallet after a successful payment."
-                    ></q-input>
-                  </div>
-                </div>
-                <div class="row">
-                  <div class="col-12">
-                    <q-input
-                      filled
-                      dense
-                      v-model="formDialog.data.success_url"
-                      type="text"
-                      label="Success URL (optional)"
-                      hint="Link will be shown to the sender after a successful payment."
-                    >
-                    </q-input>
-                  </div>
-                </div>
-              </q-card-section>
-              <q-card-section>
-                <h5 class="text-caption q-mt-sm q-mb-none">Nostr</h5>
-                <div class="row">
-                  <div class="col-12">
-                    <q-checkbox
-                      :toggle-indeterminate="false"
-                      dense
-                      v-model="formDialog.data.zaps"
-                      label="Enable nostr zaps"
-                    />
-                  </div>
-                </div>
-              </q-card-section>
-            </q-card>
-          </q-expansion-item>
-          <div class="row q-mt-lg">
-            <q-btn
-              v-if="formDialog.data.id"
-              unelevated
-              color="primary"
-              type="submit"
-              >Update pay link</q-btn
-            >
-            <q-btn
-              v-else
-              unelevated
-              color="primary"
-              :disable="
-                formDialog.data.wallet == null ||
-                formDialog.data.description == null ||
-                formDialog.data.min == null ||
-                formDialog.data.min <= 0
-              "
-              type="submit"
-              >Create pay link</q-btn
-            >
-            <q-btn v-close-popup flat color="grey" class="q-ml-auto"
-              >Cancel</q-btn
-            >
-          </div>
-        </q-form>
-      </q-card>
-    </q-dialog>
-
-    <q-dialog v-model="qrCodeDialog.show" position="top">
-      <q-card v-if="qrCodeDialog.data" class="q-pa-lg lnbits__dialog-card">
-        <lnbits-qrcode-lnurl :url="activeUrl" :nfc="true"></lnbits-qrcode-lnurl>
-        <p style="word-break: break-all">
-          <strong>ID:</strong> <span v-text="qrCodeDialog.data.id"></span><br />
-          <strong>Amount:</strong>
-          <span v-text="qrCodeDialog.data.amount"></span><br />
-
-          <span v-if="qrCodeDialog.data.currency"
-            ><strong
-              ><span v-text="qrCodeDialog.data.currency"></span> price:</strong
-            >
-            <span
-              v-if="fiatRates[qrCodeDialog.data.currency]"
-              v-text="fiatRates[qrCodeDialog.data.currency] + 'sat'"
-            ></span>
-            <span v-else>Loading...</span>
-            <br
-          /></span>
-          <strong>Accepts comments:</strong>
-          <span v-text="qrCodeDialog.data.comments"></span><br />
-          <strong>Dispatches webhook to:</strong>
-          <span v-text="qrCodeDialog.data.webhook"></span><br />
-          <strong>On success:</strong>
-          <span v-text="qrCodeDialog.data.success"></span><br />
-          <span v-if="qrCodeDialog.data.username">
-            <strong>Lightning Address: </strong>
-            <span v-text="lnaddress(qrCodeDialog.data)"></span>
-            <q-icon
-              name="content_copy"
-              class="text-grey cursor-pointer q-ml-sm"
-              @click="utils.copyText(lnaddress(qrCodeDialog.data))"
-            ></q-icon>
-            <q-icon name="qr_code" class="text-grey cursor-pointer q-ml-sm">
-              <q-popup-proxy>
-                <lnbits-qrcode
-                  class="q-pa-md"
-                  :value="lnaddress(qrCodeDialog.data)"
-                  :show-buttons="false"
-                ></lnbits-qrcode>
-              </q-popup-proxy>
-            </q-icon>
-            <br />
-          </span>
-        </p>
-        <div class="row q-mt-lg q-gutter-sm">
-          <q-btn
-            outline
-            color="grey"
-            icon="link"
-            @click="
-              utils.copyText(
-                qrCodeDialog.data.pay_url,
-                'Link copied to clipboard!'
-              )
-            "
-            ><q-tooltip>Copy sharable link</q-tooltip>
-          </q-btn>
-          <q-btn v-close-popup flat color="grey" class="q-ml-auto">Close</q-btn>
-        </div>
-      </q-card>
-    </q-dialog>
-  </div>
-</template>

static/js/index.js

@@ -1,69 +1,37 @@
-window.PageLnurlp = {
+/* globals Quasar, Vue, _, VueQrcode, windowMixin, LNbits, LOCALE */
-  template: '#page-lnurlp',
+
-  computed: {
+Vue.component(VueQrcode.name, VueQrcode)
-    baseUrl() {
+
-      return window.location.origin + '/lnurlp/api/v1/links'
+var locationPath = [
-    },
+  window.location.protocol,
-    endpoint() {
+  '//',
-      return `/lnurlp/api/v1/settings?usr=${this.g.user.id}`
+  window.location.host,
-    }
+  window.location.pathname
-  },
+].join('')
+
+var mapPayLink = obj => {
+  obj._data = _.clone(obj)
+  obj.date = Quasar.utils.date.formatDate(
+    new Date(obj.time * 1000),
+    'YYYY-MM-DD HH:mm'
+  )
+  obj.amount = new Intl.NumberFormat(LOCALE).format(obj.amount)
+  obj.print_url = [locationPath, 'print/', obj.id].join('')
+  obj.pay_url = [locationPath, 'link/', obj.id].join('')
+  return obj
+}
+
+new Vue({
+  el: '#vue',
+  mixins: [windowMixin],
   data() {
     return {
-      activeUrl: '',
-      settings: [
-        {
-          type: 'str',
-          description: 'Nostr private key used to zap',
-          name: 'nostr_private_key'
-        }
-      ],
       domain: window.location.host,
+      currencies: [],
       fiatRates: {},
+      checker: null,
       payLinks: [],
       payLinksTable: {
-        columns: [
-          {
-            name: 'created_at',
-            label: 'Created',
-            align: 'left',
-            field: 'created_at',
-            sortable: true
-          },
-          {
-            name: 'description',
-            label: 'Description',
-            align: 'left',
-            field: 'description'
-          },
-          {
-            name: 'amount',
-            label: 'Amount',
-            align: 'left',
-            format: (_, row) => {
-              const min = row.min
-              const max = row.max
-              if (min === max) return `${min}`
-              return `${min} - ${max}`
-            }
-          },
-          {
-            name: 'currency',
-            label: 'Currency',
-            align: 'left',
-            field: 'currency',
-            format: val => val ?? 'sat'
-          },
-          {
-            name: 'username',
-            label: 'Username',
-            align: 'left',
-            field: 'username',
-            sortable: true,
-            format: val => val ?? 'None',
-            classes: val => (val ? 'text-normal' : 'text-grey')
-          }
-        ],
         pagination: {
           rowsPerPage: 10
         }
@@ -73,8 +41,7 @@ window.PageLnurlp = {
         show: false,
         fixedAmount: true,
         data: {
-          disposable: true,
+          zaps:false
-          zaps: false
         }
       },
       qrCodeDialog: {
@@ -84,28 +51,6 @@ window.PageLnurlp = {
     }
   },
   methods: {
-    lnaddress(link) {
-      const domain = link.domain || window.location.host
-      return `${link.username}@${domain}`
-    },
-    mapPayLink(obj) {
-      const locationPath = [
-        window.location.protocol,
-        '//',
-        window.location.host,
-        window.location.pathname
-      ].join('')
-      obj._data = _.clone(obj)
-      obj.created_at = LNbits.utils.formatDate(obj.created_at)
-      obj.updated_at = LNbits.utils.formatDate(obj.updated_at)
-      if (obj.currency) {
-        obj.min = obj.min / obj.fiat_base_multiplier
-        obj.max = obj.max / obj.fiat_base_multiplier
-      }
-      obj.print_url = [locationPath, 'print/', obj.id].join('')
-      obj.pay_url = [locationPath, 'link/', obj.id].join('')
-      return obj
-    },
     getPayLinks() {
       LNbits.api
         .request(
@@ -114,9 +59,12 @@ window.PageLnurlp = {
           this.g.user.wallets[0].inkey
         )
         .then(response => {
-          this.payLinks = response.data.map(this.mapPayLink)
+          this.payLinks = response.data.map(mapPayLink)
+        })
+        .catch(err => {
+          clearInterval(this.checker)
+          LNbits.utils.notifyApiError(err)
         })
-        .catch(LNbits.utils.notifyApiError)
     },
     closeFormDialog() {
       this.resetFormData()
@@ -144,20 +92,17 @@ window.PageLnurlp = {
               (link.success_url ? ' and URL "' + link.success_url + '"' : '')
             : 'do nothing',
         lnurl: link.lnurl,
-        domain: link.domain,
         pay_url: link.pay_url,
         print_url: link.print_url,
         username: link.username
       }
-      const domain = link.domain || window.location.host
-      this.activeUrl = `https://${domain}/lnurlp/${link.id}`
       this.qrCodeDialog.show = true
     },
     openUpdateDialog(linkId) {
       const link = _.findWhere(this.payLinks, {id: linkId})
       if (link.currency) this.updateFiatRate(link.currency)
 
-      this.formDialog.data = {...link}
+      this.formDialog.data = _.clone(link._data)
       this.formDialog.show = true
       this.formDialog.fixedAmount =
         this.formDialog.data.min === this.formDialog.data.max
@@ -166,10 +111,12 @@ window.PageLnurlp = {
       const wallet = _.findWhere(this.g.user.wallets, {
         id: this.formDialog.data.wallet
       })
-      const data = _.clone(this.formDialog.data)
+      var data = _.omit(this.formDialog.data, 'wallet')
+
       if (this.formDialog.fixedAmount) data.max = data.min
       if (data.currency === 'satoshis') data.currency = null
       if (isNaN(parseInt(data.comment_chars))) data.comment_chars = 0
+
       if (data.id) {
         this.updatePayLink(wallet, data)
       } else {
@@ -184,16 +131,37 @@ window.PageLnurlp = {
       }
     },
     updatePayLink(wallet, data) {
+      let values = _.omit(
+        _.pick(
+          data,
+          'description',
+          'min',
+          'max',
+          'webhook_url',
+          'success_text',
+          'success_url',
+          'comment_chars',
+          'currency',
+          'username',
+          'zaps'
+        ),
+        (value, key) =>
+          (key === 'webhook_url' ||
+            key === 'success_text' ||
+            key === 'success_url') &&
+          (value === null || value === '')
+      )
+
       LNbits.api
         .request(
           'PUT',
           '/lnurlp/api/v1/links/' + data.id,
           wallet.adminkey,
-          data
+          values
         )
         .then(response => {
           this.payLinks = _.reject(this.payLinks, obj => obj.id === data.id)
-          this.payLinks.push(this.mapPayLink(response.data))
+          this.payLinks.push(mapPayLink(response.data))
           this.formDialog.show = false
           this.resetFormData()
         })
@@ -225,7 +193,7 @@ window.PageLnurlp = {
               '/lnurlp/api/v1/links/' + linkId,
               _.findWhere(this.g.user.wallets, {id: link.wallet}).adminkey
             )
-            .then(() => {
+            .then(response => {
               this.payLinks = _.reject(this.payLinks, obj => obj.id === linkId)
             })
             .catch(err => {
@@ -235,18 +203,68 @@ window.PageLnurlp = {
     },
     updateFiatRate(currency) {
       LNbits.api
-        .request('GET', '/api/v1/rate/' + currency, null)
+        .request('GET', '/lnurlp/api/v1/rate/' + currency, null)
         .then(response => {
-          this.fiatRates[currency] = response.data.rate
+          let rates = _.clone(this.fiatRates)
+          rates[currency] = response.data.rate
+          this.fiatRates = rates
         })
         .catch(err => {
           LNbits.utils.notifyApiError(err)
         })
+    },
+    writeNfcTag: async function (lnurl) {
+      try {
+        if (typeof NDEFReader == 'undefined') {
+          throw {
+            toString: function () {
+              return 'NFC not supported on this device or browser.'
+            }
+          }
+        }
+
+        const ndef = new NDEFReader()
+
+        this.nfcTagWriting = true
+        this.$q.notify({
+          message: 'Tap your NFC tag to write the LNURL-pay link to it.'
+        })
+
+        await ndef.write({
+          records: [{recordType: 'url', data: 'lightning:' + lnurl, lang: 'en'}]
+        })
+
+        this.nfcTagWriting = false
+        this.$q.notify({
+          type: 'positive',
+          message: 'NFC tag written successfully.'
+        })
+      } catch (error) {
+        this.nfcTagWriting = false
+        this.$q.notify({
+          type: 'negative',
+          message: error
+            ? error.toString()
+            : 'An unexpected error has occurred.'
+        })
+      }
     }
   },
   created() {
-    if (this.g.user.wallets?.length) {
+    if (this.g.user.wallets.length) {
-      this.getPayLinks()
+      var getPayLinks = this.getPayLinks
+      getPayLinks()
+      this.checker = setInterval(() => {
+        getPayLinks()
+      }, 20000)
     }
+    LNbits.api
+      .request('GET', '/lnurlp/api/v1/currencies')
+      .then(response => {
+        this.currencies = ['satoshis', ...response.data]
+      })
+      .catch(err => {
+        LNbits.utils.notifyApiError(err)
+      })
   }
-}
+})

static/routes.json

@@ -1,14 +0,0 @@
-[
-  {
-    "path": "/lnurlp/",
-    "name": "PageLnurlp",
-    "template": "/lnurlp/static/index.vue",
-    "component": "/lnurlp/static/index.js"
-  },
-  {
-    "path": "/lnurlp/link/:id",
-    "name": "PageLnurlpPublic",
-    "template": "/lnurlp/static/display.vue",
-    "component": "/lnurlp/static/display.js"
-  }
-]

tasks.py

@@ -2,20 +2,27 @@ import asyncio
 import json
 
 import httpx
-import websockets
-from lnbits.core.crud import get_payment, update_payment
-from lnbits.core.models import Payment
-from lnbits.tasks import register_invoice_listener
 from loguru import logger
-from pynostr.event import Event
 
-from .crud import get_or_create_lnurlp_settings, get_pay_link
+from lnbits.core.crud import update_payment_extra
-from .models import PayLink
+from lnbits.core.models import Payment
+from lnbits.helpers import get_current_extension_name
+from lnbits.tasks import register_invoice_listener
+from websocket import WebSocketApp
+from lnbits.settings import settings
+from .crud import get_pay_link
+from threading import Thread
+from . import nostr_privatekey
+from typing import List
+import time
+
+from .nostr.event import Event
+from .nostr.key import PrivateKey, PublicKey
 
 
 async def wait_for_paid_invoices():
     invoice_queue = asyncio.Queue()
-    register_invoice_listener(invoice_queue, "ext_lnurlp")
+    register_invoice_listener(invoice_queue, get_current_extension_name())
 
     while True:
         payment = await invoice_queue.get()
@@ -23,155 +30,120 @@ async def wait_for_paid_invoices():
 
 
 async def on_invoice_paid(payment: Payment):
-    if not payment.extra or payment.extra.get("tag") != "lnurlp":
+    if payment.extra.get("tag") != "lnurlp":
         return
 
     if payment.extra.get("wh_status"):
         # this webhook has already been sent
         return
 
-    pay_link_id = payment.extra.get("link")
+    pay_link = await get_pay_link(payment.extra.get("link", -1))
-    if not pay_link_id:
+    if pay_link and pay_link.webhook_url:
-        logger.error("Invoice paid. But no pay link id found.")
+        async with httpx.AsyncClient() as client:
-        return
+            try:
-
+                r: httpx.Response = await client.post(
-    pay_link = await get_pay_link(pay_link_id)
+                    pay_link.webhook_url,
-    if not pay_link:
+                    json={
-        logger.error(f"Invoice paid. But Pay link `{pay_link_id}` not found.")
+                        "payment_hash": payment.payment_hash,
-        return
+                        "payment_request": payment.bolt11,
-
+                        "amount": payment.amount,
-    zap_receipt = None
+                        "comment": payment.extra.get("comment"),
-    if pay_link.zaps:
+                        "lnurlp": pay_link.id,
-        zap_receipt = await send_zap(payment)
+                        "body": json.loads(pay_link.webhook_body)
-
-    await send_webhook(
-        payment, pay_link, zap_receipt.to_message() if zap_receipt else None
-    )
-
-
-async def send_webhook(payment: Payment, pay_link: PayLink, zap_receipt=None):
-    if not pay_link.webhook_url:
-        return
-
-    async with httpx.AsyncClient() as client:
-        try:
-            r: httpx.Response = await client.post(
-                pay_link.webhook_url,
-                json={
-                    "payment_hash": payment.payment_hash,
-                    "payment_request": payment.bolt11,
-                    "amount": payment.amount,
-                    "comment": payment.extra.get("comment") if payment.extra else None,
-                    "webhook_data": (
-                        payment.extra.get("webhook_data") if payment.extra else None
-                    ),
-                    "lnurlp": pay_link.id,
-                    "body": (
-                        json.loads(pay_link.webhook_body)
                         if pay_link.webhook_body
-                        else ""
+                        else "",
-                    ),
+                    },
-                    "zap_receipt": zap_receipt or "",
+                    headers=json.loads(pay_link.webhook_headers)
-                },
-                headers=(
-                    json.loads(pay_link.webhook_headers)
                     if pay_link.webhook_headers
-                    else None
+                    else None,
-                ),
+                    timeout=40,
-                timeout=6,
+                )
-            )
+                await mark_webhook_sent(
-            await mark_webhook_sent(
+                    payment.payment_hash,
-                payment.checking_id,
+                    r.status_code,
-                r.status_code,
+                    r.is_success,
-                r.is_success,
+                    r.reason_phrase,
-                r.reason_phrase,
+                    r.text,
-                r.text,
+                )
-            )
+            except Exception as ex:
-        except Exception as exc:
+                logger.error(ex)
-            logger.error(exc)
+                await mark_webhook_sent(
-            await mark_webhook_sent(
+                    payment.payment_hash, -1, False, "Unexpected Error", str(ex)
-                payment.checking_id, -1, False, "Unexpected Error", str(exc)
+                )
-            )
+
+    # NIP-57
+    # load the zap request
+    nostr = payment.extra.get("nostr")
+    if pay_link and pay_link.zaps and nostr:
+        event_json = json.loads(nostr)
+
+        def get_tag(event_json, tag):
+            res = [
+                event_tag[1:] for event_tag in event_json["tags"] if event_tag[0] == tag
+            ]
+            return res[0] if res else None
+
+        tags = []
+        for t in ["p", "e"]:
+            tag = get_tag(event_json, t)
+            if tag:
+                tags.append([t, tag[0]])
+        tags.append(["bolt11", payment.bolt11])
+        tags.append(["description", nostr])
+        zap_receipt = Event(
+            kind=9735, tags=tags, content=payment.extra.get("comment") or ""
+        )
+        nostr_privatekey.sign_event(zap_receipt)
+
+        def send_zap(relay):
+            def send_event(_):
+                logger.debug(f"Sending zap to {ws.url}")
+                ws.send(zap_receipt.to_message())
+                time.sleep(2)
+                ws.close()
+
+            ws = WebSocketApp(relay, on_open=send_event)
+            wst = Thread(target=ws.run_forever, name=f"LNURL zap {relay}")
+            wst.daemon = True
+            wst.start()
+            return ws, wst
+
+        # list of all websockets
+        wss: List[WebSocketApp] = []
+        # list of all threads for these websockets
+        wsts: List[Thread] = []
+
+        # # send zap via nostrclient
+        # ws, wst = send_zap(f"wss://localhost:{settings.port}/nostrclient/api/v1/relay")
+        # wss += [ws]
+        # wsts += [wst]
+
+        # send zap receipt to relays in zap request
+        relays = get_tag(event_json, "relays")
+        if relays:
+            if len(relays) > 50:
+                relays = relays[:50]
+            for r in relays:
+                ws, wst = send_zap(r)
+                wss += [ws]
+                wsts += [wst]
+
+        await asyncio.sleep(10)
+        for ws, wst in zip(wss, wsts):
+            logger.debug(f"Closing websocket {ws.url}")
+            ws.close()
+            wst.join()
 
 
 async def mark_webhook_sent(
-    checking_id: str, status: int, is_success: bool, reason_phrase="", text=""
+    payment_hash: str, status: int, is_success: bool, reason_phrase="", text=""
 ) -> None:
-    payment = await get_payment(checking_id)
+    await update_payment_extra(
-    extra = payment.extra or {}
+        payment_hash,
-    extra["wh_status"] = status  # keep for backwards compability
+        {
-    extra["wh_success"] = is_success
+            "wh_status": status,  # keep for backwards compability
-    extra["wh_message"] = reason_phrase
+            "wh_success": is_success,
-    extra["wh_response"] = text
+            "wh_message": reason_phrase,
-    payment.extra = extra
+            "wh_response": text,
-    await update_payment(payment)
+        },
-
-
-# NIP-57 - load the zap request
-async def send_zap(payment: Payment):
-    nostr = payment.extra.get("nostr") if payment.extra else None
-    if not nostr:
-        return
-
-    event_json = json.loads(nostr)
-
-    def get_tag(event_json, tag):
-        res = [event_tag[1:] for event_tag in event_json["tags"] if event_tag[0] == tag]
-        return res[0] if res else None
-
-    tags = []
-    for t in ["p", "e", "a"]:
-        tag = get_tag(event_json, t)
-        if tag:
-            tags.append([t, tag[0]])
-    tags.append(["bolt11", payment.bolt11])
-    tags.append(["description", nostr])
-
-    pubkey = next((pk[1] for pk in tags if pk[0] == "p"), None)
-    assert pubkey, "Cannot create zap receipt. Recepient pubkey is missing."
-    zap_receipt = Event(
-        kind=9735,
-        tags=tags,
-        content="",
     )
-
-    settings = await get_or_create_lnurlp_settings()
-    zap_receipt.sign(settings.private_key.hex())
-
-    async def send_to_relay(relay_url: str, event_message: str):
-        """Helper function to send an event to a single relay."""
-        try:
-            async with websockets.connect(relay_url, open_timeout=5) as websocket:
-                logger.debug(f"Sending zap to {relay_url}")
-                await websocket.send(event_message)
-                response = await asyncio.wait_for(websocket.recv(), timeout=5)
-                relay_response = json.loads(response)
-                if relay_response[0] != "OK" or not relay_response[2]:
-                    logger.debug(
-                        f"Relay did not acknowledge zap receipt: {relay_response}"
-                    )
-                    return
-                logger.debug(f"Zap sent to {relay_url} successfully")
-        except asyncio.TimeoutError:
-            logger.debug(f"Relay did not acknowledge zap receipt: {relay_url}")
-        except Exception as e:
-            logger.warning(f"Failed to send zap to {relay_url}: {e}")
-
-    # Get relays from the zap request, with a reasonable limit
-    relays = get_tag(event_json, "relays")
-    if not relays:
-        return zap_receipt
-
-    if len(relays) > 50:
-        relays = relays[:50]
-
-    # Create a list of tasks to run concurrently
-
-    # Run all tasks concurrently. This is a "fire-and-forget" approach.
-    # We don't need to wait for all of them to complete here.
-    _ = [
-        asyncio.create_task(send_to_relay(relay, zap_receipt.to_message()))
-        for relay in relays
-    ]
-
-    return zap_receipt

templates/lnurlp/_api_docs.html

@@ -0,0 +1,138 @@
+<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#/lnurlp"></q-btn>
+  <q-expansion-item group="api" dense expand-separator label="List pay links">
+    <q-card>
+      <q-card-section>
+        <code><span class="text-blue">GET</span> /lnurlp/api/v1/links</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code>{"X-Api-Key": &lt;invoice_key&gt;}</code><br />
+        <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 200 OK (application/json)
+        </h5>
+        <code>[&lt;pay_link_object&gt;, ...]</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X GET {{ request.base_url }}lnurlp/api/v1/links -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 a pay link">
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-blue">GET</span>
+          /lnurlp/api/v1/links/&lt;pay_id&gt;</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code>{"X-Api-Key": &lt;invoice_key&gt;}</code><br />
+        <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>{"lnurl": &lt;string&gt;}</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X GET {{ request.base_url }}lnurlp/api/v1/links/&lt;pay_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="Create a pay link"
+  >
+    <q-btn flat label="Swagger API" type="a" href="../docs#/lnurlp"></q-btn>
+    <q-card>
+      <q-card-section>
+        <code><span class="text-green">POST</span> /lnurlp/api/v1/links</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code>{"X-Api-Key": &lt;admin_key&gt;}</code><br />
+        <h5 class="text-caption q-mt-sm q-mb-none">Body (application/json)</h5>
+        <code
+          >{"description": &lt;string&gt; "amount": &lt;integer&gt; "max":
+          &lt;integer&gt; "min": &lt;integer&gt; "comment_chars":
+          &lt;integer&gt; "username": &lt;string&gt; }</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">
+          Returns 201 CREATED (application/json)
+        </h5>
+        <code>{"lnurl": &lt;string&gt;}</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X POST {{ request.base_url }}lnurlp/api/v1/links -d
+          '{"description": &lt;string&gt;, "amount": &lt;integer&gt;, "max":
+          &lt;integer&gt;, "min": &lt;integer&gt;, "comment_chars":
+          &lt;integer&gt;}' -H "Content-type: application/json" -H "X-Api-Key:
+          {{ user.wallets[0].adminkey }}"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+  <q-expansion-item
+    group="api"
+    dense
+    expand-separator
+    label="Update a pay link"
+  >
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-green">PUT</span>
+          /lnurlp/api/v1/links/&lt;pay_id&gt;</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code>{"X-Api-Key": &lt;admin_key&gt;}</code><br />
+        <h5 class="text-caption q-mt-sm q-mb-none">Body (application/json)</h5>
+        <code>{"description": &lt;string&gt;, "amount": &lt;integer&gt;}</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">
+          Returns 200 OK (application/json)
+        </h5>
+        <code>{"lnurl": &lt;string&gt;}</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X PUT {{ request.base_url }}lnurlp/api/v1/links/&lt;pay_id&gt;
+          -d '{"description": &lt;string&gt;, "amount": &lt;integer&gt;}' -H
+          "Content-type: application/json" -H "X-Api-Key: {{
+          user.wallets[0].adminkey }}"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+  <q-expansion-item
+    group="api"
+    dense
+    expand-separator
+    label="Delete a pay link"
+    class="q-pb-md"
+  >
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-pink">DELETE</span>
+          /lnurlp/api/v1/links/&lt;pay_id&gt;</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code>{"X-Api-Key": &lt;admin_key&gt;}</code><br />
+        <h5 class="text-caption q-mt-sm q-mb-none">Returns 204 NO CONTENT</h5>
+        <code></code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X DELETE {{ request.base_url
+          }}lnurlp/api/v1/links/&lt;pay_id&gt; -H "X-Api-Key: {{
+          user.wallets[0].adminkey }}"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+</q-expansion-item>

templates/lnurlp/_lnurl.html

@@ -0,0 +1,31 @@
+<q-expansion-item group="extras" icon="info" label="Powered by LNURL">
+  <q-card>
+    <q-card-section>
+      <p>
+        <b>WARNING: LNURL must be used over https or TOR</b><br />
+        LNURL is a range of lightning-network standards that allow us to use
+        lightning-network differently. An LNURL-pay is a link that wallets use
+        to fetch an invoice from a server on-demand. The link or QR code is
+        fixed, but each time it is read by a compatible wallet a new QR code is
+        issued by the service. It can be used to activate machines without them
+        having to maintain an electronic screen to generate and show invoices
+        locally, or to sell any predefined good or service automatically.
+      </p>
+      <p>
+        Exploring LNURL and finding use cases, is really helping inform
+        lightning protocol development, rather than the protocol dictating how
+        lightning-network should be engaged with.
+      </p>
+      <small
+        >Check
+        <a
+          class="text-secondary"
+          href="https://github.com/fiatjaf/awesome-lnurl"
+          target="_blank"
+          >Awesome LNURL</a
+        >
+        for further information.</small
+      >
+    </q-card-section>
+  </q-card>
+</q-expansion-item>

templates/lnurlp/display.html

@@ -0,0 +1,54 @@
+{% extends "public.html" %} {% block page %}
+<div class="row q-col-gutter-md justify-center">
+  <div class="col-12 col-sm-6 col-md-5 col-lg-4">
+    <q-card class="q-pa-lg">
+      <q-card-section class="q-pa-none">
+        <div class="text-center">
+          <a class="text-secondary" href="lightning:{{ lnurl }}">
+            <q-responsive :ratio="1" class="q-mx-md">
+              <qrcode
+                value="lightning:{{ lnurl }}"
+                :options="{width: 800}"
+                class="rounded-borders"
+              ></qrcode>
+            </q-responsive>
+          </a>
+        </div>
+        <div class="row q-mt-lg q-gutter-sm">
+          <q-btn outline color="grey" @click="copyText('{{ lnurl }}')"
+            >Copy LNURL</q-btn
+          >
+          <q-btn
+            outline
+            color="grey"
+            icon="nfc"
+            @click="writeNfcTag(' {{ lnurl }} ')"
+            :disable="nfcTagWriting"
+          ></q-btn>
+        </div>
+      </q-card-section>
+    </q-card>
+  </div>
+  <div class="col-12 col-sm-6 col-md-5 col-lg-4 q-gutter-y-md">
+    <q-card>
+      <q-card-section>
+        <h6 class="text-subtitle1 q-mb-sm q-mt-none">LNbits LNURL-pay link</h6>
+        <p class="q-my-none">Use an LNURL compatible bitcoin wallet to pay.</p>
+      </q-card-section>
+      <q-card-section class="q-pa-none">
+        <q-separator></q-separator>
+        <q-list> {% include "lnurlp/_lnurl.html" %} </q-list>
+      </q-card-section>
+    </q-card>
+  </div>
+</div>
+{% endblock %} {% block scripts %}
+<script>
+  Vue.component(VueQrcode.name, VueQrcode)
+
+  new Vue({
+    el: '#vue',
+    mixins: [windowMixin]
+  })
+</script>
+{% endblock %}

templates/lnurlp/index.html

@@ -0,0 +1,428 @@
+{% 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-7 q-gutter-y-md">
+    <q-card>
+      <q-card-section>
+        <q-btn unelevated color="primary" @click="formDialog.show = true"
+          >New pay link</q-btn
+        >
+      </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">Pay links</h5>
+          </div>
+        </div>
+        <q-table
+          dense
+          flat
+          :data="payLinks"
+          row-key="id"
+          :pagination.sync="payLinksTable.pagination"
+        >
+          {% raw %}
+          <template v-slot:header="props">
+            <q-tr class="text-left" :props="props">
+              <q-th auto-width></q-th>
+              <q-th auto-width>Description</q-th>
+              <q-th auto-width>Amount</q-th>
+              <q-th auto-width>Currency</q-th>
+              <q-th auto-width>Username</q-th>
+              <q-th auto-width></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="launch"
+                  :color="($q.dark.isActive) ? 'grey-7' : 'grey-5'"
+                  type="a"
+                  :href="props.row.pay_url"
+                  target="_blank"
+                  ><q-tooltip>Sharable Page</q-tooltip></q-btn
+                >
+                <q-btn
+                  unelevated
+                  dense
+                  size="xs"
+                  icon="visibility"
+                  :color="($q.dark.isActive) ? 'grey-7' : 'grey-5'"
+                  @click="openQrCodeDialog(props.row.id)"
+                  ><q-tooltip>View Link</q-tooltip></q-btn
+                >
+              </q-td>
+              <q-td auto-width>{{ props.row.description }}</q-td>
+              <q-td auto-width>
+                <span v-if="props.row.min == props.row.max">
+                  {{ props.row.min }}
+                </span>
+                <span v-else>{{ props.row.min }} - {{ props.row.max }}</span>
+              </q-td>
+              <q-td>{{ props.row.currency || 'sat' }}</q-td>
+              <q-td
+                auto-width
+                :class="(props.row.username) ? 'text-normal' : 'text-grey'"
+                >{{ props.row.username || 'None' }}</q-td
+              >
+              <q-td>
+                <q-icon v-if="props.row.webhook_url" size="14px" name="http">
+                  <q-tooltip>Webhook to {{ props.row.webhook_url }}</q-tooltip>
+                </q-icon>
+                <q-icon
+                  v-if="props.row.success_text || props.row.success_url"
+                  size="14px"
+                  name="call_to_action"
+                >
+                  <q-tooltip>
+                    On success, show message '{{ props.row.success_text }}'
+                    <span v-if="props.row.success_url"
+                      >and URL '{{ props.row.success_url }}'</span
+                    >
+                  </q-tooltip>
+                </q-icon>
+                <q-icon
+                  v-if="props.row.comment_chars > 0"
+                  size="14px"
+                  name="insert_comment"
+                >
+                  <q-tooltip>
+                    {{ props.row.comment_chars }}-char comment allowed
+                  </q-tooltip>
+                </q-icon>
+              </q-td>
+              <q-td auto-width>
+                <q-btn
+                  flat
+                  dense
+                  size="xs"
+                  @click="openUpdateDialog(props.row.id)"
+                  icon="edit"
+                  color="light-blue"
+                >
+                  <q-tooltip>Edit</q-tooltip>
+                </q-btn>
+                <q-btn
+                  flat
+                  dense
+                  size="xs"
+                  @click="deletePayLink(props.row.id)"
+                  icon="cancel"
+                  color="pink"
+                  ><q-tooltip>Delete</q-tooltip></q-btn
+                >
+              </q-td>
+            </q-tr>
+          </template>
+          {% endraw %}
+        </q-table>
+      </q-card-section>
+    </q-card>
+  </div>
+
+  <div class="col-12 col-md-5 q-gutter-y-md">
+    <q-card>
+      <q-card-section>
+        <h6 class="text-subtitle1 q-my-none">
+          {{ SITE_TITLE }} LNURL-pay extension
+        </h6>
+      </q-card-section>
+      <q-card-section class="q-pa-none">
+        <q-separator></q-separator>
+        <q-list>
+          {% include "lnurlp/_api_docs.html" %}
+          <q-separator></q-separator>
+          {% include "lnurlp/_lnurl.html" %}
+        </q-list>
+      </q-card-section>
+    </q-card>
+  </div>
+
+  <q-dialog v-model="formDialog.show" @hide="closeFormDialog">
+    <q-card class="q-pa-lg q-pt-xl lnbits__dialog-card">
+      <q-form @submit="sendFormData" class="q-gutter-md">
+        <q-select
+          filled
+          dense
+          emit-value
+          v-model="formDialog.data.wallet"
+          :options="g.user.walletOptions"
+          label="Wallet *"
+        >
+        </q-select>
+        <q-input
+          filled
+          dense
+          v-model.trim="formDialog.data.description"
+          type="text"
+          label="Item description *"
+        >
+        </q-input>
+        <div class="row">
+          <div class="col">
+            <q-input
+              filled
+              dense
+              v-model.trim="formDialog.data.username"
+              type="text"
+              label="Lightning Address"
+            />
+          </div>
+          <div class="col" style="margin-top: 10px">
+            <span class="label">
+              &nbsp; @ {% raw %} {{ domain }} {% endraw %}
+            </span>
+          </div>
+        </div>
+        <div class="row q-col-gutter-sm q-mx-sm">
+          <q-input
+            filled
+            dense
+            v-model.number="formDialog.data.min"
+            type="number"
+            :step="formDialog.data.currency && formDialog.data.currency !== 'satoshis' ? '0.01' : '1'"
+            :label="formDialog.fixedAmount ? 'Amount *' : 'Min *'"
+          ></q-input>
+          <q-input
+            v-if="!formDialog.fixedAmount"
+            filled
+            dense
+            v-model.number="formDialog.data.max"
+            type="number"
+            :step="formDialog.data.currency && formDialog.data.currency !== 'satoshis' ? '0.01' : '1'"
+            label="Max *"
+          >
+          </q-input>
+        </div>
+        <div class="row q-col-gutter-sm">
+          <div class="col">
+            <q-checkbox
+              dense
+              v-model="formDialog.fixedAmount"
+              label="Fixed amount"
+            />
+          </div>
+          <div class="col">
+            <q-select
+              dense
+              :options="currencies"
+              v-model="formDialog.data.currency"
+              :display-value="formDialog.data.currency || 'satoshis'"
+              label="Currency"
+              :hint="'Converted to satoshis at each payment. ' + (formDialog.data.currency && fiatRates[formDialog.data.currency] ? `Currently 1 ${formDialog.data.currency} = ${fiatRates[formDialog.data.currency]} sat` : '')"
+              @input="updateFiatRate"
+            />
+          </div>
+        </div>
+        <q-expansion-item
+          group="advanced"
+          icon="settings"
+          label="Advanced options"
+        >
+        <q-card>
+          <q-card-section>
+            <h5 class="text-caption q-mt-sm q-mb-none">LNURL</h5>
+          <div class="row">
+            <div class="col-12">
+              <q-input
+                filled
+                dense
+                v-model.number="formDialog.data.comment_chars"
+                type="number"
+                label="Comment maximum characters"
+                hint="Allow the payer to attach a comment."
+              >
+              </q-input>
+            </div>
+          </div>
+          <div class="row">
+            <div class="col-12">
+              <q-input
+                filled
+                dense
+                v-model="formDialog.data.webhook_url"
+                type="text"
+                label="Webhook URL (optional)"
+                hint="A URL to be called whenever this link receives a payment."
+              ></q-input>
+            </div>
+          </div>
+          <div class="row">
+            <div class="col-12">
+              <q-input
+                filled
+                dense
+                v-if="formDialog.data.webhook_url"
+                v-model="formDialog.data.webhook_headers"
+                type="text"
+                label="Webhook headers (optional)"
+                hint="Custom data as JSON string, send headers along with the webhook."
+              ></q-input>
+            </div>
+          </div>
+          <div class="row">
+            <div class="col-12">
+              <q-input
+                filled
+                dense
+                v-if="formDialog.data.webhook_url"
+                v-model="formDialog.data.webhook_body"
+                type="text"
+                label="Webhook custom data (optional)"
+                hint="Custom data as JSON string, will get posted along with webhook 'body' field."
+              ></q-input>
+            </div>
+          </div>
+          <div class="row">
+            <div class="col-12">
+              <q-input
+                filled
+                dense
+                v-model="formDialog.data.success_text"
+                type="text"
+                label="Success message (optional)"
+                hint="Will be shown to the user in his wallet after a successful payment."
+              ></q-input>
+            </div>
+          </div>
+          <div class="row">
+            <div class="col-12">
+              <q-input
+                filled
+                dense
+                v-model="formDialog.data.success_url"
+                type="text"
+                label="Success URL (optional)"
+                hint="Link will be shown to the sender after a successful payment."
+              >
+              </q-input>
+            </div>
+          </div>
+        </q-card-section>
+        <q-card-section>
+          <h5 class="text-caption q-mt-sm q-mb-none">Nostr</h5>
+          <div class="row">
+            <div class="col-12">
+              <q-checkbox
+                :toggle-indeterminate="false"
+                dense
+                v-model="formDialog.data.zaps"
+                label="Enable nostr zaps"
+              />
+            </div>
+          </div>
+        </q-card-section>
+        </q-card>
+        </q-expansion-item>
+        <div class="row q-mt-lg">
+          <q-btn
+            v-if="formDialog.data.id"
+            unelevated
+            color="primary"
+            type="submit"
+            >Update pay link</q-btn
+          >
+          <q-btn
+            v-else
+            unelevated
+            color="primary"
+            :disable="
+                formDialog.data.wallet == null ||
+                formDialog.data.description == null ||
+                (
+                  formDialog.data.min == null ||
+                  formDialog.data.min <= 0
+                )
+                "
+            type="submit"
+            >Create pay link</q-btn
+          >
+          <q-btn v-close-popup flat color="grey" class="q-ml-auto"
+            >Cancel</q-btn
+          >
+        </div>
+      </q-form>
+    </q-card>
+  </q-dialog>
+
+  <q-dialog v-model="qrCodeDialog.show" position="top">
+    <q-card v-if="qrCodeDialog.data" class="q-pa-lg lnbits__dialog-card">
+      {% raw %}
+      <q-responsive :ratio="1" class="q-mx-xl q-mb-md">
+        <qrcode
+          :value="'lightning:' + qrCodeDialog.data.lnurl"
+          :options="{width: 800}"
+          class="rounded-borders"
+        ></qrcode>
+      </q-responsive>
+      <p style="word-break: break-all">
+        <strong>ID:</strong> {{ qrCodeDialog.data.id }}<br />
+        <strong>Amount:</strong> {{ qrCodeDialog.data.amount }}<br />
+        <span v-if="qrCodeDialog.data.currency"
+          ><strong>{{ qrCodeDialog.data.currency }} price:</strong>
+          {{
+            fiatRates[qrCodeDialog.data.currency]
+              ? fiatRates[qrCodeDialog.data.currency] + ' sat'
+              : 'Loading...'
+          }}<br
+        /></span>
+        <strong>Accepts comments:</strong> {{ qrCodeDialog.data.comments
+        }}<br />
+        <strong>Dispatches webhook to:</strong> {{ qrCodeDialog.data.webhook
+        }}<br />
+        <strong>On success:</strong> {{ qrCodeDialog.data.success }}<br />
+        <span v-if="qrCodeDialog.data.username">
+          <strong>Lightning Address: </strong>
+          {{ qrCodeDialog.data.username }}@{{ domain }}
+          <br />
+        </span>
+      </p>
+      {% endraw %}
+      <div class="row q-mt-lg q-gutter-sm">
+        <q-btn
+          outline
+          color="grey"
+          @click="copyText(qrCodeDialog.data.lnurl, 'LNURL copied to clipboard!')"
+          class="q-ml-sm"
+          >Copy LNURL</q-btn
+        >
+        <q-btn
+          outline
+          color="grey"
+          icon="link"
+          @click="copyText(qrCodeDialog.data.pay_url, 'Link copied to clipboard!')"
+          ><q-tooltip>Copy sharable link</q-tooltip>
+        </q-btn>
+        <q-btn
+          outline
+          color="grey"
+          icon="nfc"
+          @click="writeNfcTag(qrCodeDialog.data.lnurl)"
+          :disable="nfcTagWriting"
+          ><q-tooltip>Write to NFC</q-tooltip>
+        </q-btn>
+        <q-btn
+          outline
+          color="grey"
+          icon="print"
+          type="a"
+          :href="qrCodeDialog.data.print_url"
+          target="_blank"
+          ><q-tooltip>Print</q-tooltip></q-btn
+        >
+        <q-btn v-close-popup flat color="grey" class="q-ml-auto">Close</q-btn>
+      </div>
+    </q-card>
+  </q-dialog>
+</div>
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+<script src="/lnurlp/static/js/index.js"></script>
+{% endblock %}

templates/lnurlp/print_qr.html

@@ -0,0 +1,27 @@
+{% extends "print.html" %} {% block page %}
+<div class="row justify-center">
+  <div class="qr">
+    <qrcode value="lightning:{{ lnurl }}" :options="{width}"></qrcode>
+  </div>
+</div>
+{% endblock %} {% block styles %}
+<style>
+  .qr {
+    margin: auto;
+  }
+</style>
+{% endblock %} {% block scripts %}
+<script>
+  Vue.component(VueQrcode.name, VueQrcode)
+
+  new Vue({
+    el: '#vue',
+    created: function () {
+      window.print()
+    },
+    data: function () {
+      return {width: window.innerWidth * 0.5}
+    }
+  })
+</script>
+{% endblock %}

tests/test_init.py

@@ -1,11 +0,0 @@
-import pytest
-from fastapi import APIRouter
-
-from .. import lnurlp_ext
-
-
-# just import router and add it to a test router
-@pytest.mark.asyncio
-async def test_router():
-    router = APIRouter()
-    router.include_router(lnurlp_ext)

toc.md

@@ -1,29 +0,0 @@
-# Terms and Conditions for LNbits Extension
-
-## 1. Acceptance of Terms
-
-By installing and using the LNbits extension ("Extension"), you agree to be bound by these terms and conditions ("Terms"). If you do not agree to these Terms, do not use the Extension.
-
-## 2. License
-
-The Extension is free and open-source software, released under [specify the FOSS license here, e.g., GPL-3.0, MIT, etc.]. You are permitted to use, copy, modify, and distribute the Extension under the terms of that license.
-
-## 3. No Warranty
-
-The Extension is provided "as is" and with all faults, and the developer expressly disclaims all warranties of any kind, whether express, implied, statutory, or otherwise, including but not limited to warranties of merchantability, fitness for a particular purpose, non-infringement, and any warranties arising out of course of dealing or usage of trade. No advice or information, whether oral or written, obtained from the developer or elsewhere will create any warranty not expressly stated in this Terms.
-
-## 4. Limitation of Liability
-
-In no event will the developer be liable to you or any third party for any direct, indirect, incidental, special, consequential, or punitive damages, including lost profit, lost revenue, loss of data, or other damages arising out of or in connection with your use of the Extension, even if the developer has been advised of the possibility of such damages. The foregoing limitation of liability shall apply to the fullest extent permitted by law in the applicable jurisdiction.
-
-## 5. Modification of Terms
-
-The developer reserves the right to modify these Terms at any time. You are advised to review these Terms periodically for any changes. Changes to these Terms are effective when they are posted on the appropriate location within or associated with the Extension.
-
-## 6. General Provisions
-
-If any provision of these Terms is held to be invalid or unenforceable, that provision will be enforced to the maximum extent permissible, and the other provisions of these Terms will remain in full force and effect. These Terms constitute the entire agreement between you and the developer regarding the use of the Extension.
-
-## 7. Contact Information
-
-If you have any questions about these Terms, please contact the developer at [developer's contact information].

transport_rpcs.py

@@ -1,151 +0,0 @@
-"""
-Nostr-transport RPC handlers for the lnurlp (LNURL-pay) extension.
-
-Exposes the same CRUD surface that `views_api.py` exposes via HTTP, but
-encrypted over kind-21000 events through the LNbits nostr transport.
-Mirrors the withdraw extension's `transport_rpcs.py`; both extensions
-hang their handlers off the core dispatcher via their `*_start()` hook.
-
-Auth model (set by the registrations in `__init__.py:lnurlp_start`):
-- *_create / *_get / *_update / *_delete → AUTH_WALLET. The transport
-  resolves the caller's pubkey to a wallet (admin access) before
-  invoking the handler, so we know `auth.wallet.id` and `auth.wallet.user`.
-- *_list → AUTH_ACCOUNT. The caller may list links across all wallets
-  they own, optionally narrowed by `request.wallet_id`.
-
-Ownership: *_get / *_update / *_delete also verify the link's stored
-`wallet` field matches the caller's wallet id — defense in depth, since
-a malicious client could otherwise probe link metadata they don't own.
-
-`resolve_lnurlp_owner` is registered with the core subscription module
-under tag `"lnurlp"` (default link_extra_key `"link"` — that's where
-`views_lnurl.py:86` stamps the link id on settlement). That lets clients
-call `subscribe_payments({tag:"lnurlp", link_id:...})` and stream real-
-time pay events without polling, with ownership enforced server-side.
-"""
-
-from __future__ import annotations
-
-from lnbits.core.crud.wallets import get_wallets
-from lnbits.core.models import Account
-from lnbits.core.models.wallets import WalletTypeInfo
-from lnbits.core.services.nostr_transport.models import NostrRpcRequest
-
-from .crud import (
-    create_pay_link,
-    delete_pay_link,
-    get_pay_link,
-    get_pay_links,
-    update_pay_link,
-)
-from .models import CreatePayLinkData
-
-
-async def handle_lnurlp_create(
-    auth: WalletTypeInfo, request: NostrRpcRequest
-) -> dict:
-    body = request.body or {}
-    body["wallet"] = auth.wallet.id  # always create under the calling wallet
-    data = CreatePayLinkData(**body)
-    link = await create_pay_link(data)
-    return _to_dict(link)
-
-
-async def handle_lnurlp_get(
-    auth: WalletTypeInfo, request: NostrRpcRequest
-) -> dict:
-    link_id = _require_id(request)
-    link = await _require_owned_link(link_id, auth.wallet.id)
-    return _to_dict(link)
-
-
-async def handle_lnurlp_list(
-    auth: Account, request: NostrRpcRequest
-) -> list[dict]:
-    """List PayLinks across all wallets owned by the calling account.
-    If `request.wallet_id` is set and is one of those wallets, narrow to
-    just that wallet."""
-    wallets = await get_wallets(auth.id)
-    wallet_ids = [w.id for w in wallets]
-    if not wallet_ids:
-        return []
-    if request.wallet_id and request.wallet_id in wallet_ids:
-        wallet_ids = [request.wallet_id]
-    links = await get_pay_links(wallet_ids)
-    return [_to_dict(link) for link in links]
-
-
-async def handle_lnurlp_update(
-    auth: WalletTypeInfo, request: NostrRpcRequest
-) -> dict:
-    link_id = _require_id(request)
-    link = await _require_owned_link(link_id, auth.wallet.id)
-    body = request.body or {}
-    # Only patchable fields. Identity / counter fields (id, wallet,
-    # served_meta, served_pr, created_at) are not client-mutable.
-    _MUTABLE = {
-        "description",
-        "min",
-        "max",
-        "comment_chars",
-        "currency",
-        "webhook_url",
-        "webhook_headers",
-        "webhook_body",
-        "success_text",
-        "success_url",
-        "fiat_base_multiplier",
-        "username",
-        "zaps",
-        "disposable",
-        "domain",
-    }
-    for k, v in body.items():
-        if k in _MUTABLE:
-            setattr(link, k, v)
-    updated = await update_pay_link(link)
-    return _to_dict(updated)
-
-
-async def handle_lnurlp_delete(
-    auth: WalletTypeInfo, request: NostrRpcRequest
-) -> dict:
-    link_id = _require_id(request)
-    await _require_owned_link(link_id, auth.wallet.id)
-    await delete_pay_link(link_id)
-    return {"ok": True}
-
-
-async def resolve_lnurlp_owner(link_id: str) -> str | None:
-    """For the core subscription module: link_id -> wallet_id (or None)."""
-    link = await get_pay_link(link_id)
-    return link.wallet if link else None
-
-
-# ---------------------------------------------------------------------------
-# helpers
-# ---------------------------------------------------------------------------
-
-
-def _require_id(request: NostrRpcRequest) -> str:
-    body = request.body or {}
-    link_id = body.get("id")
-    if not link_id:
-        raise ValueError("lnurlp: body.id is required")
-    return str(link_id)
-
-
-async def _require_owned_link(link_id: str, wallet_id: str):
-    link = await get_pay_link(link_id)
-    if link is None:
-        raise ValueError(f"lnurlp: link not found: {link_id}")
-    if link.wallet != wallet_id:
-        raise PermissionError(
-            "lnurlp: link does not belong to caller's wallet"
-        )
-    return link
-
-
-def _to_dict(link) -> dict:
-    import json
-    return json.loads(link.json())

views.py

@@ -1,17 +1,43 @@
-from fastapi import APIRouter, Depends
+from http import HTTPStatus
-from lnbits.core.views.generic import index, index_public
+
+from fastapi import Depends, Request
+from fastapi.templating import Jinja2Templates
+from starlette.exceptions import HTTPException
+from starlette.responses import HTMLResponse
+
+from lnbits.core.models import User
 from lnbits.decorators import check_user_exists
 
-lnurlp_generic_router = APIRouter()
+from . import lnurlp_ext, lnurlp_renderer
+from .crud import get_pay_link
 
-lnurlp_generic_router.add_api_route(
+templates = Jinja2Templates(directory="templates")
-    "/", methods=["GET"], endpoint=index, dependencies=[Depends(check_user_exists)]
-)
 
-lnurlp_generic_router.add_api_route(
-    "/link/{link_id}", methods=["GET"], endpoint=index_public
-)
 
-lnurlp_generic_router.add_api_route(
+@lnurlp_ext.get("/", response_class=HTMLResponse)
-    "/print/{link_id}", methods=["GET"], endpoint=index_public
+async def index(request: Request, user: User = Depends(check_user_exists)):
-)
+    return lnurlp_renderer().TemplateResponse(
+        "lnurlp/index.html", {"request": request, "user": user.dict()}
+    )
+
+
+@lnurlp_ext.get("/link/{link_id}", response_class=HTMLResponse)
+async def display(request: Request, link_id):
+    link = await get_pay_link(link_id)
+    if not link:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="Pay link does not exist."
+        )
+    ctx = {"request": request, "lnurl": link.lnurl(req=request)}
+    return lnurlp_renderer().TemplateResponse("lnurlp/display.html", ctx)
+
+
+@lnurlp_ext.get("/print/{link_id}", response_class=HTMLResponse)
+async def print_qr(request: Request, link_id):
+    link = await get_pay_link(link_id)
+    if not link:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="Pay link does not exist."
+        )
+    ctx = {"request": request, "lnurl": link.lnurl(req=request)}
+    return lnurlp_renderer().TemplateResponse("lnurlp/print_qr.html", ctx)

views_api.py

@@ -1,73 +1,70 @@
 import json
-import re
+from asyncio.log import logger
 from http import HTTPStatus
+from urllib.parse import urlparse
 
-from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from fastapi import Depends, Query, Request
-from lnbits.core.crud import get_user, get_wallet
+from lnurl.exceptions import InvalidUrl as LnurlInvalidUrl
-from lnbits.core.models import SimpleStatus, WalletTypeInfo
+from starlette.exceptions import HTTPException
-from lnbits.decorators import (
-    check_admin,
-    require_admin_key,
-    require_invoice_key,
-)
-from lnurl import InvalidUrl
 
+from lnbits.core.crud import get_user
+from lnbits.decorators import WalletTypeInfo, check_admin, get_key_type
+from lnbits.utils.exchange_rates import currencies, get_fiat_rate_satoshis
+
+from . import lnurlp_ext, scheduled_tasks
 from .crud import (
     create_pay_link,
-    delete_lnurlp_settings,
     delete_pay_link,
-    get_or_create_lnurlp_settings,
     get_pay_link,
-    get_pay_link_by_username,
     get_pay_links,
-    update_lnurlp_settings,
     update_pay_link,
+    get_address_data,
 )
-from .helpers import lnurl_encode_link, parse_nostr_private_key
+from .models import CreatePayLinkData
-from .models import CreatePayLinkData, LnurlpSettings, PayLink, PublicPayLink
+from .lnurl import api_lnurl_response
 
-lnurlp_api_router = APIRouter()
+# redirected from /.well-known/lnurlp
+@lnurlp_ext.get("/api/v1/well-known/{username}")
+async def lnaddress(username: str, request: Request):
+    address_data = await get_address_data(username)
+    assert address_data, "User not found"
+    return await api_lnurl_response(request, address_data.id, lnaddress=True)
 
 
-def check_lnurl_encode(req: Request, link: PayLink) -> str:
+@lnurlp_ext.get("/api/v1/currencies")
-    try:
+async def api_list_currencies_available():
-        return lnurl_encode_link(req, link.id, link.domain)
+    return list(currencies.keys())
-    except InvalidUrl as exc:
-        raise HTTPException(
-            detail=(
-                f"Invalid URL for LNURL encoding: `{req.base_url}`. "
-                "Check proxy settings."
-            ),
-            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-        ) from exc
-    except Exception as exc:
-        raise HTTPException(
-            detail="Error encoding LNURL.",
-            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-        ) from exc
 
 
-@lnurlp_api_router.get("/api/v1/links", status_code=HTTPStatus.OK)
+@lnurlp_ext.get("/api/v1/links", status_code=HTTPStatus.OK)
 async def api_links(
     req: Request,
-    key_info: WalletTypeInfo = Depends(require_invoice_key),
+    wallet: WalletTypeInfo = Depends(get_key_type),
     all_wallets: bool = Query(False),
-) -> list[PayLink]:
+):
-    wallet_ids = [key_info.wallet.id]
+    wallet_ids = [wallet.wallet.id]
+
     if all_wallets:
-        user = await get_user(key_info.wallet.user)
+        user = await get_user(wallet.wallet.user)
         wallet_ids = user.wallet_ids if user else []
 
-    links = await get_pay_links(wallet_ids)
+    try:
-    for link in links:
+        return [
-        link.lnurl = check_lnurl_encode(req, link)
+            {**link.dict(), "lnurl": link.lnurl(req)}
-    return links
+            for link in await get_pay_links(wallet_ids)
+        ]
+
+    except LnurlInvalidUrl:
+        raise HTTPException(
+            status_code=HTTPStatus.UPGRADE_REQUIRED,
+            detail="LNURLs need to be delivered over a publically accessible `https` domain or Tor.",
+        )
 
 
-@lnurlp_api_router.get("/api/v1/links/{link_id}")
+@lnurlp_ext.get("/api/v1/links/{link_id}", status_code=HTTPStatus.OK)
 async def api_link_retrieve(
-    req: Request, link_id: str, key_info: WalletTypeInfo = Depends(require_invoice_key)
+    r: Request, link_id, wallet: WalletTypeInfo = Depends(get_key_type)
-) -> PayLink:
+):
     link = await get_pay_link(link_id)
 
     if not link:
@@ -75,76 +72,52 @@ async def api_link_retrieve(
             detail="Pay link does not exist.", status_code=HTTPStatus.NOT_FOUND
         )
 
-    link_wallet = await get_wallet(link.wallet)
+    if link.wallet != wallet.wallet.id:
-
-    # admins are allowed to read paylinks beloging to regular users
-    user = await get_user(key_info.wallet.user)
-    admin_user = user.admin if user else False
-    if not admin_user and link_wallet and link_wallet.user != key_info.wallet.user:
         raise HTTPException(
             detail="Not your pay link.", status_code=HTTPStatus.FORBIDDEN
         )
 
-    link.lnurl = check_lnurl_encode(req, link)
+    return {**link.dict(), **{"lnurl": link.lnurl(r)}}
-    return link
 
 
-@lnurlp_api_router.get("/api/v1/links/public/{link_id}", response_model=PublicPayLink)
+@lnurlp_ext.post("/api/v1/links", status_code=HTTPStatus.CREATED)
-async def api_link_public_retrieve(req: Request, link_id: str) -> PayLink:
+@lnurlp_ext.put("/api/v1/links/{link_id}", status_code=HTTPStatus.OK)
-    link = await get_pay_link(link_id)
-    if not link:
-        raise HTTPException(
-            detail="Pay link does not exist.", status_code=HTTPStatus.NOT_FOUND
-        )
-    link.lnurl = lnurl_encode_link(req, link.id, link.domain)
-    return link
-
-
-async def check_username_exists(username: str):
-    prev_link = await get_pay_link_by_username(username)
-    if prev_link:
-        raise HTTPException(
-            detail="Username already taken.",
-            status_code=HTTPStatus.CONFLICT,
-        )
-
-
-@lnurlp_api_router.post("/api/v1/links", status_code=HTTPStatus.CREATED)
-@lnurlp_api_router.put("/api/v1/links/{link_id}", status_code=HTTPStatus.OK)
 async def api_link_create_or_update(
-    req: Request,
     data: CreatePayLinkData,
-    link_id: str | None = None,
+    request: Request,
-    key_info: WalletTypeInfo = Depends(require_admin_key),
+    link_id=None,
-) -> PayLink:
+    wallet: WalletTypeInfo = Depends(get_key_type),
+):
+
     if data.min > data.max:
         raise HTTPException(
             detail="Min is greater than max.", status_code=HTTPStatus.BAD_REQUEST
         )
 
-    if not data.currency:
+    if data.currency is None and (
-        if round(data.min) != data.min or round(data.max) != data.max or data.min < 1:
+        round(data.min) != data.min or round(data.max) != data.max or data.min < 1
-            raise HTTPException(
+    ):
-                detail="Must use full satoshis.", status_code=HTTPStatus.BAD_REQUEST
+        raise HTTPException(
-            )
+            detail="Must use full satoshis.", status_code=HTTPStatus.BAD_REQUEST
+        )
 
     if data.webhook_headers:
         try:
             json.loads(data.webhook_headers)
-        except ValueError as exc:
+        except ValueError:
             raise HTTPException(
                 detail="Invalid JSON in webhook_headers.",
                 status_code=HTTPStatus.BAD_REQUEST,
-            ) from exc
+            )
 
     if data.webhook_body:
         try:
             json.loads(data.webhook_body)
-        except ValueError as exc:
+        except ValueError:
             raise HTTPException(
                 detail="Invalid JSON in webhook_body.",
                 status_code=HTTPStatus.BAD_REQUEST,
-            ) from exc
+            )
 
     # database only allows int4 entries for min and max. For fiat currencies,
     # we multiply by data.fiat_base_multiplier (usually 100) to save the value in cents.
@@ -152,41 +125,12 @@ async def api_link_create_or_update(
         data.min *= data.fiat_base_multiplier
         data.max *= data.fiat_base_multiplier
 
-    if (
+    if data.success_url is not None and not data.success_url.startswith("https://"):
-        data.success_url
-        and data.success_url != ""
-        and not data.success_url.startswith("https://")
-    ):
         raise HTTPException(
             detail="Success URL must be secure https://...",
             status_code=HTTPStatus.BAD_REQUEST,
         )
 
-    if data.username and not re.match("^[a-z0-9-_.]{1,210}$", data.username):
-        raise HTTPException(
-            detail=f"Invalid username: {data.username}. "
-            "Only letters a-z0-9-_. allowed, min 1 and max 210 characters!",
-            status_code=HTTPStatus.BAD_REQUEST,
-        )
-
-    # if wallet is not provided, use the wallet of the key
-    if not data.wallet:
-        data.wallet = key_info.wallet.id
-
-    new_wallet = await get_wallet(data.wallet)
-    if not new_wallet:
-        raise HTTPException(
-            detail="Wallet does not exist.", status_code=HTTPStatus.FORBIDDEN
-        )
-
-    # admins are allowed to create/edit paylinks belonging to regular users
-    user = await get_user(key_info.wallet.user)
-    admin_user = user.admin if user else False
-    if not admin_user and new_wallet.user != key_info.wallet.user:
-        raise HTTPException(
-            detail="Not your pay link.", status_code=HTTPStatus.FORBIDDEN
-        )
-
     if link_id:
         link = await get_pay_link(link_id)
 
@@ -195,27 +139,20 @@ async def api_link_create_or_update(
                 detail="Pay link does not exist.", status_code=HTTPStatus.NOT_FOUND
             )
 
-        if data.username and data.username != link.username:
+        if link.wallet != wallet.wallet.id:
-            await check_username_exists(data.username)
+            raise HTTPException(
+                detail="Not your pay link.", status_code=HTTPStatus.FORBIDDEN
+            )
 
-        for k, v in data.dict().items():
+        link = await update_pay_link(**data.dict(), link_id=link_id)
-            setattr(link, k, v)
-
-        link = await update_pay_link(link)
     else:
-        if data.username:
+        link = await create_pay_link(data, wallet_id=wallet.wallet.id)
-            await check_username_exists(data.username)
+    assert link
-
+    return {**link.dict(), "lnurl": link.lnurl(request)}
-        link = await create_pay_link(data)
-
-    link.lnurl = check_lnurl_encode(req, link)
-    return link
 
 
-@lnurlp_api_router.delete("/api/v1/links/{link_id}", status_code=HTTPStatus.OK)
+@lnurlp_ext.delete("/api/v1/links/{link_id}", status_code=HTTPStatus.OK)
-async def api_link_delete(
+async def api_link_delete(link_id, wallet: WalletTypeInfo = Depends(get_key_type)):
-    link_id: str, key_info: WalletTypeInfo = Depends(require_admin_key)
-) -> SimpleStatus:
     link = await get_pay_link(link_id)
 
     if not link:
@@ -223,34 +160,31 @@ async def api_link_delete(
             detail="Pay link does not exist.", status_code=HTTPStatus.NOT_FOUND
         )
 
-    # admins are allowed to delete paylinks belonging to regular users
+    if link.wallet != wallet.wallet.id:
-    user = await get_user(key_info.wallet.user)
-    admin_user = user.admin if user else False
-    if not admin_user and link.wallet != key_info.wallet.id:
         raise HTTPException(
             detail="Not your pay link.", status_code=HTTPStatus.FORBIDDEN
         )
 
     await delete_pay_link(link_id)
-    return SimpleStatus(success=True, message="Deleted Pay link")
+    return {"success": True}
 
 
-@lnurlp_api_router.get("/api/v1/settings", dependencies=[Depends(check_admin)])
+@lnurlp_ext.get("/api/v1/rate/{currency}", status_code=HTTPStatus.OK)
-async def api_get_or_create_settings() -> LnurlpSettings:
+async def api_check_fiat_rate(currency):
-    return await get_or_create_lnurlp_settings()
-
-
-@lnurlp_api_router.put("/api/v1/settings", dependencies=[Depends(check_admin)])
-async def api_update_settings(data: LnurlpSettings) -> LnurlpSettings:
     try:
-        parse_nostr_private_key(data.nostr_private_key)
+        rate = await get_fiat_rate_satoshis(currency)
-    except Exception as exc:
+    except AssertionError:
-        raise HTTPException(
+        rate = None
-            detail="Invalid Nostr private key.", status_code=HTTPStatus.BAD_REQUEST
+
-        ) from exc
+    return {"rate": rate}
-    return await update_lnurlp_settings(data)
 
 
-@lnurlp_api_router.delete("/api/v1/settings", dependencies=[Depends(check_admin)])
+@lnurlp_ext.delete("/api/v1", status_code=HTTPStatus.OK)
-async def api_delete_settings() -> None:
+async def api_stop(wallet: WalletTypeInfo = Depends(check_admin)):
-    await delete_lnurlp_settings()
+    for t in scheduled_tasks:
+        try:
+            t.cancel()
+        except Exception as ex:
+            logger.warning(ex)
+
+    return {"success": True}

views_lnurl.py

@@ -1,208 +0,0 @@
-import json
-from http import HTTPStatus
-
-from fastapi import APIRouter, HTTPException, Query, Request
-from lnbits.core.services import create_invoice
-from lnbits.utils.exchange_rates import get_fiat_rate_satoshis
-from lnurl import (
-    CallbackUrl,
-    LightningInvoice,
-    LnurlErrorResponse,
-    LnurlPayActionResponse,
-    LnurlPayMetadata,
-    LnurlPayResponse,
-    LnurlPaySuccessActionTag,
-    Max144Str,
-    MessageAction,
-    MilliSatoshi,
-    UrlAction,
-)
-from pydantic import parse_obj_as
-
-from .crud import (
-    get_address_data,
-    get_or_create_lnurlp_settings,
-    get_pay_link,
-    update_pay_link,
-)
-
-lnurlp_lnurl_router = APIRouter()
-
-
-@lnurlp_lnurl_router.get(
-    "/api/v1/lnurl/cb/{link_id}",
-    status_code=HTTPStatus.OK,
-    name="lnurlp.api_lnurl_callback",
-)
-async def api_lnurl_callback(
-    request: Request,
-    link_id: str,
-    amount: int = Query(...),
-    webhook_data: str = Query(None),
-) -> LnurlErrorResponse | LnurlPayActionResponse:
-    link = await get_pay_link(link_id)
-    if not link:
-        raise HTTPException(
-            status_code=HTTPStatus.NOT_FOUND, detail="Pay link does not exist."
-        )
-    link.served_pr = 1
-    await update_pay_link(link)
-    minimum = link.min
-    maximum = link.max
-
-    rate = await get_fiat_rate_satoshis(link.currency) if link.currency else 1
-    if link.currency and link.fiat_base_multiplier:
-        link.min = link.min / link.fiat_base_multiplier
-        link.max = link.max / link.fiat_base_multiplier
-        # allow some fluctuation (as the fiat price may have changed between the calls)
-        minimum = rate * 995 * link.min
-        maximum = rate * 1010 * link.max
-    else:
-        minimum = link.min * 1000
-        maximum = link.max * 1000
-
-    amount = amount
-    if amount < minimum:
-        return LnurlErrorResponse(
-            reason=f"Amount {amount} is smaller than minimum {minimum}."
-        )
-
-    elif amount > maximum:
-        return LnurlErrorResponse(
-            reason=f"Amount {amount} is greater than maximum {maximum}."
-        )
-
-    comment = request.query_params.get("comment")
-    if len(comment or "") > link.comment_chars:
-        return LnurlErrorResponse(
-            reason=(
-                f"Got a comment with {len(comment or '')} characters, "
-                f"but can only accept {link.comment_chars}"
-            )
-        )
-
-    extra = {
-        "tag": "lnurlp",
-        "link": link.id,
-        "extra": request.query_params.get("amount"),
-    }
-
-    if comment:
-        extra["comment"] = comment
-
-    if webhook_data:
-        extra["webhook_data"] = webhook_data
-
-    # nip 57
-    nostr = request.query_params.get("nostr")
-    if nostr:
-        extra["nostr"] = nostr  # put it here for later publishing in tasks.py
-
-    if link.username:
-        identifier = f"{link.username}@{link.domain or request.url.netloc}"
-        text = f"Payment to {link.username}"
-        _metadata = [["text/plain", text], ["text/identifier", identifier]]
-        extra["lnaddress"] = identifier
-    else:
-        _metadata = [["text/plain", link.description]]
-
-    metadata = LnurlPayMetadata(json.dumps(_metadata))
-
-    # we take the zap request as the description instead of the metadata if present
-    unhashed_description = nostr.encode() if nostr else metadata.encode()
-
-    payment = await create_invoice(
-        wallet_id=link.wallet,
-        amount=int(amount / 1000),
-        memo=link.description,
-        unhashed_description=unhashed_description,
-        extra=extra,
-    )
-    invoice = parse_obj_as(LightningInvoice, LightningInvoice(payment.bolt11))
-
-    if link.success_url:
-        url = parse_obj_as(CallbackUrl, str(link.success_url))
-        text = link.success_text or f"Link to {link.success_url}"
-        desc = parse_obj_as(Max144Str, text)
-        action = UrlAction(tag=LnurlPaySuccessActionTag.url, url=url, description=desc)
-        return LnurlPayActionResponse(
-            pr=invoice, successAction=action, disposable=link.disposable
-        )
-
-    if link.success_text:
-        message = parse_obj_as(Max144Str, link.success_text)
-        return LnurlPayActionResponse(
-            pr=invoice,
-            successAction=MessageAction(message=message),
-            disposable=link.disposable,
-        )
-
-    return LnurlPayActionResponse(pr=invoice, disposable=link.disposable)
-
-
-@lnurlp_lnurl_router.get(
-    "/api/v1/lnurl/{link_id}",  # Backwards compatibility for old LNURLs / QR codes
-    name="lnurlp.api_lnurl_response.deprecated",
-    deprecated=True,
-)
-@lnurlp_lnurl_router.get(
-    "/{link_id}",
-    name="lnurlp.api_lnurl_response",
-)
-async def api_lnurl_response(
-    request: Request, link_id: str, webhook_data: str | None = Query(None)
-) -> LnurlPayResponse:
-    link = await get_pay_link(link_id)
-    if not link:
-        raise HTTPException(
-            status_code=HTTPStatus.NOT_FOUND, detail="Pay link does not exist."
-        )
-    link.served_meta = 1
-    await update_pay_link(link)
-
-    rate = await get_fiat_rate_satoshis(link.currency) if link.currency else 1
-
-    if link.currency and link.fiat_base_multiplier:
-        link.min = link.min / link.fiat_base_multiplier
-        link.max = link.max / link.fiat_base_multiplier
-
-    url = request.url_for("lnurlp.api_lnurl_callback", link_id=link.id)
-    if webhook_data:
-        url = url.include_query_params(webhook_data=webhook_data)
-
-    callback_url = parse_obj_as(CallbackUrl, str(url))
-
-    if link.username:
-        identifier = f"{link.username}@{link.domain or request.url.netloc}"
-        text = f"Payment to {link.username}"
-        metadata = [["text/plain", text], ["text/identifier", identifier]]
-    else:
-        metadata = [["text/plain", link.description]]
-
-    res = LnurlPayResponse(
-        callback=callback_url,
-        minSendable=MilliSatoshi(round(link.min * rate) * 1000),
-        maxSendable=MilliSatoshi(round(link.max * rate) * 1000),
-        metadata=LnurlPayMetadata(json.dumps(metadata)),
-    )
-
-    if link.comment_chars > 0:
-        res.commentAllowed = link.comment_chars
-
-    if link.zaps:
-        settings = await get_or_create_lnurlp_settings()
-        res.allowsNostr = True
-        res.nostrPubkey = settings.public_key
-
-    return res
-
-
-# redirected from /.well-known/lnurlp
-@lnurlp_lnurl_router.get("/api/v1/well-known/{username}")
-async def lnaddress(
-    username: str, request: Request
-) -> LnurlPayResponse | LnurlErrorResponse:
-    address_data = await get_address_data(username)
-    if not address_data:
-        return LnurlErrorResponse(reason="Lightning address not found.")
-    return await api_lnurl_response(request, address_data.id)