+ StreamerCopilot: get tips via static QR (lnurl-pay) and show an
+ animation
+
+ Created by, Ben Arc
+
POST /copilot/api/v1/copilot
+ Headers
+{"X-Api-Key": <admin_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<copilot_object>, ...]
+ Curl example
+curl -X POST {{ request.url_root }}api/v1/copilot -d '{"title":
+ <string>, "animation": <string>,
+ "show_message":<string>, "amount": <integer>,
+ "lnurl_title": <string>}' -H "Content-type: application/json"
+ -H "X-Api-Key: {{user.wallets[0].adminkey }}"
+
+ PUT
+ /copilot/api/v1/copilot/<copilot_id>
+ Headers
+{"X-Api-Key": <admin_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<copilot_object>, ...]
+ Curl example
+curl -X POST {{ request.url_root
+ }}api/v1/copilot/<copilot_id> -d '{"title": <string>,
+ "animation": <string>, "show_message":<string>,
+ "amount": <integer>, "lnurl_title": <string>}' -H
+ "Content-type: application/json" -H "X-Api-Key:
+ {{user.wallets[0].adminkey }}"
+
+ GET
+ /copilot/api/v1/copilot/<copilot_id>
+ Headers
+{"X-Api-Key": <invoice_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<copilot_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/copilot/<copilot_id>
+ -H "X-Api-Key: {{ user.wallets[0].inkey }}"
+
+ GET /copilot/api/v1/copilots
+ Headers
+{"X-Api-Key": <invoice_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<copilot_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/copilots -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ DELETE
+ /copilot/api/v1/copilot/<copilot_id>
+ Headers
+{"X-Api-Key": <admin_key>}+
Returns 204 NO CONTENT
+Curl example
+curl -X DELETE {{ request.url_root
+ }}api/v1/copilot/<copilot_id> -H "X-Api-Key: {{
+ user.wallets[0].adminkey }}"
+
+ GET
+ /api/v1/copilot/ws/<copilot_id>/<comment>/<data>
+ Headers
+{"X-Api-Key": <admin_key>}+
Returns 200
+Curl example
+curl -X GET {{ request.url_root }}/api/v1/copilot/ws/<string,
+ copilot_id>/<string, comment>/<string, gif name> -H
+ "X-Api-Key: {{ user.wallets[0].adminkey }}"
+
+
+
+
+
+
+ {% raw %}{{ copilot.lnurl_title }}{% endraw %}
+
+
+ + {% raw %}{{ price }}{% endraw %} +
++ Powered by LNbits/StreamerCopilot +
+
+
+
+
+
+
+
+
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+
+{% endblock %}
diff --git a/lnbits/extensions/copilot/templates/copilot/panel.html b/lnbits/extensions/copilot/templates/copilot/panel.html
new file mode 100644
index 00000000..f17bf34c
--- /dev/null
+++ b/lnbits/extensions/copilot/templates/copilot/panel.html
@@ -0,0 +1,156 @@
+{% extends "public.html" %} {% block page %}
+
+
+
+ {% raw %}
+ New copilot instance
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Panel
+
+
+
+
+ Compose window
+
+
+
+
+ Delete copilot
+
+
+
+
+ Edit copilot
+
+
+
+
+
+
+
+ {% endraw %}
+
+
+
+
+
+
+
+
+
+
+ Copilots
+
+
+
+
+ Export to CSV
+
+ {{ col.label }}
+ {{ col.value }}
+
+
+
+
+
+ {% include "copilot/_api_docs.html" %}
+
+
+
+ + {{SITE_TITLE}} StreamCopilot Extension +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Update Copilot
+ Create Copilot
+ Cancel
+
+
+
+
+
+
+{% endblock %} {% block scripts %}
+
+{% endblock %}
diff --git a/lnbits/extensions/copilot/views.py b/lnbits/extensions/copilot/views.py
new file mode 100644
index 00000000..17e05081
--- /dev/null
+++ b/lnbits/extensions/copilot/views.py
@@ -0,0 +1,88 @@
+from http import HTTPStatus
+from typing import List
+import httpx
+from collections import defaultdict
+from lnbits.decorators import check_user_exists
+from .crud import get_copilot
+
+from functools import wraps
+
+from lnbits.decorators import check_user_exists
+
+from . import copilot_ext, copilot_renderer
+from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect
+from fastapi.params import Depends
+from fastapi.templating import Jinja2Templates
+from fastapi.param_functions import Query
+from starlette.exceptions import HTTPException
+from starlette.responses import HTMLResponse, JSONResponse # type: ignore
+from lnbits.core.models import User
+import base64
+
+templates = Jinja2Templates(directory="templates")
+
+
+@copilot_ext.get("/", response_class=HTMLResponse)
+async def index(request: Request, user: User = Depends(check_user_exists)):
+ return copilot_renderer().TemplateResponse(
+ "copilot/index.html", {"request": request, "user": user.dict()}
+ )
+
+
+@copilot_ext.get("/cp/", response_class=HTMLResponse)
+async def compose(request: Request):
+ return copilot_renderer().TemplateResponse(
+ "copilot/compose.html", {"request": request}
+ )
+
+
+@copilot_ext.get("/pn/", response_class=HTMLResponse)
+async def panel(request: Request):
+ return copilot_renderer().TemplateResponse(
+ "copilot/panel.html", {"request": request}
+ )
+
+
+##################WEBSOCKET ROUTES########################
+
+
+class ConnectionManager:
+ def __init__(self):
+ self.active_connections: List[WebSocket] = []
+
+ async def connect(self, websocket: WebSocket, copilot_id: str):
+ await websocket.accept()
+ websocket.id = copilot_id
+ self.active_connections.append(websocket)
+
+ def disconnect(self, websocket: WebSocket):
+ self.active_connections.remove(websocket)
+
+ async def send_personal_message(self, message: str, copilot_id: str):
+ for connection in self.active_connections:
+ if connection.id == copilot_id:
+ await connection.send_text(message)
+
+ async def broadcast(self, message: str):
+ for connection in self.active_connections:
+ await connection.send_text(message)
+
+
+manager = ConnectionManager()
+
+
+@copilot_ext.websocket("/copilot/ws/{copilot_id}", name="copilot.websocket_by_id")
+async def websocket_endpoint(websocket: WebSocket, copilot_id: str):
+ await manager.connect(websocket, copilot_id)
+ try:
+ while True:
+ data = await websocket.receive_text()
+ except WebSocketDisconnect:
+ manager.disconnect(websocket)
+
+
+async def updater(copilot_id, data, comment):
+ copilot = await get_copilot(copilot_id)
+ if not copilot:
+ return
+ await manager.send_personal_message(f"{data + '-' + comment}", copilot_id)
diff --git a/lnbits/extensions/copilot/views_api.py b/lnbits/extensions/copilot/views_api.py
new file mode 100644
index 00000000..d9342a30
--- /dev/null
+++ b/lnbits/extensions/copilot/views_api.py
@@ -0,0 +1,97 @@
+from http import HTTPStatus
+
+from fastapi import Request
+from fastapi.param_functions import Query
+from fastapi.params import Depends
+from starlette.exceptions import HTTPException
+
+from lnbits.decorators import WalletTypeInfo, get_key_type
+
+from . import copilot_ext
+from .crud import (
+ create_copilot,
+ delete_copilot,
+ get_copilot,
+ get_copilots,
+ update_copilot,
+)
+from .models import CreateCopilotData
+from .views import updater
+
+#######################COPILOT##########################
+
+
+@copilot_ext.get("/api/v1/copilot")
+async def api_copilots_retrieve(
+ req: Request, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+ wallet_user = wallet.wallet.user
+ copilots = [copilot.dict() for copilot in await get_copilots(wallet_user)]
+ try:
+ return copilots
+ except:
+ raise HTTPException(status_code=HTTPStatus.NO_CONTENT, detail="No copilots")
+
+
+@copilot_ext.get("/api/v1/copilot/{copilot_id}")
+async def api_copilot_retrieve(
+ req: Request,
+ copilot_id: str = Query(None),
+ wallet: WalletTypeInfo = Depends(get_key_type),
+):
+ copilot = await get_copilot(copilot_id)
+ if not copilot:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Copilot not found"
+ )
+ if not copilot.lnurl_toggle:
+ return copilot.dict()
+ return {**copilot.dict(), **{"lnurl": copilot.lnurl(req)}}
+
+
+@copilot_ext.post("/api/v1/copilot")
+@copilot_ext.put("/api/v1/copilot/{juke_id}")
+async def api_copilot_create_or_update(
+ data: CreateCopilotData,
+ copilot_id: str = Query(None),
+ wallet: WalletTypeInfo = Depends(get_key_type),
+):
+ data.user = wallet.wallet.user
+ data.wallet = wallet.wallet.id
+ if copilot_id:
+ copilot = await update_copilot(data, copilot_id=copilot_id)
+ else:
+ copilot = await create_copilot(data, inkey=wallet.wallet.inkey)
+ return copilot
+
+
+@copilot_ext.delete("/api/v1/copilot/{copilot_id}")
+async def api_copilot_delete(
+ copilot_id: str = Query(None), wallet: WalletTypeInfo = Depends(get_key_type)
+):
+ copilot = await get_copilot(copilot_id)
+
+ if not copilot:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Copilot does not exist"
+ )
+
+ await delete_copilot(copilot_id)
+
+ return "", HTTPStatus.NO_CONTENT
+
+
+@copilot_ext.get("/api/v1/copilot/ws/{copilot_id}/{comment}/{data}")
+async def api_copilot_ws_relay(
+ copilot_id: str = Query(None), comment: str = Query(None), data: str = Query(None)
+):
+ copilot = await get_copilot(copilot_id)
+ if not copilot:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Copilot does not exist"
+ )
+ try:
+ await updater(copilot_id, data, comment)
+ except:
+ raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="Not your copilot")
+ return ""
diff --git a/lnbits/extensions/events/README.md b/lnbits/extensions/events/README.md
new file mode 100644
index 00000000..11b62fec
--- /dev/null
+++ b/lnbits/extensions/events/README.md
@@ -0,0 +1,33 @@
+# Events
+
+## Sell tickets for events and use the built-in scanner for registering attendants
+
+Events alows you to make tickets for an event. Each ticket is in the form of a uniqque QR code. After registering, and paying for ticket, the user gets a QR code to present at registration/entrance.
+
+Events includes a shareable ticket scanner, which can be used to register attendees.
+
+## Usage
+
+1. Create an event\
+ 
+2. Fill out the event information:
+
+ - event name
+ - wallet (normally there's only one)
+ - event information
+ - closing date for event registration
+ - begin and end date of the event
+
+ 
+
+3. Share the event registration link\
+ 
+
+ - ticket example\
+ 
+
+ - QR code ticket, presented after invoice paid, to present at registration\
+ 
+
+4. Use the built-in ticket scanner to validate registered, and paid, attendees\
+ 
diff --git a/lnbits/extensions/events/__init__.py b/lnbits/extensions/events/__init__.py
new file mode 100644
index 00000000..da29358b
--- /dev/null
+++ b/lnbits/extensions/events/__init__.py
@@ -0,0 +1,19 @@
+from fastapi import APIRouter
+
+from lnbits.db import Database
+from lnbits.helpers import template_renderer
+
+db = Database("ext_events")
+
+
+events_ext: APIRouter = APIRouter(
+ prefix="/events",
+ tags=["Events"]
+)
+
+def events_renderer():
+ return template_renderer(["lnbits/extensions/events/templates"])
+
+from .views import * # noqa
+from .views_api import * # noqa
+
diff --git a/lnbits/extensions/events/config.json b/lnbits/extensions/events/config.json
new file mode 100644
index 00000000..6bc144ab
--- /dev/null
+++ b/lnbits/extensions/events/config.json
@@ -0,0 +1,6 @@
+{
+ "name": "Events",
+ "short_description": "Sell and register event tickets",
+ "icon": "local_activity",
+ "contributors": ["benarc"]
+}
diff --git a/lnbits/extensions/events/crud.py b/lnbits/extensions/events/crud.py
new file mode 100644
index 00000000..4a24b797
--- /dev/null
+++ b/lnbits/extensions/events/crud.py
@@ -0,0 +1,159 @@
+from typing import List, Optional, Union
+
+from lnbits.helpers import urlsafe_short_hash
+
+from . import db
+from .models import CreateEvent, Events, Tickets
+
+# TICKETS
+
+
+async def create_ticket(
+ payment_hash: str, wallet: str, event: str, name: str, email: str
+) -> Tickets:
+ await db.execute(
+ """
+ INSERT INTO events.ticket (id, wallet, event, name, email, registered, paid)
+ VALUES (?, ?, ?, ?, ?, ?, ?)
+ """,
+ (payment_hash, wallet, event, name, email, False, False),
+ )
+
+ ticket = await get_ticket(payment_hash)
+ assert ticket, "Newly created ticket couldn't be retrieved"
+ return ticket
+
+
+async def set_ticket_paid(payment_hash: str) -> Tickets:
+ row = await db.fetchone("SELECT * FROM events.ticket WHERE id = ?", (payment_hash,))
+ if row[6] != True:
+ await db.execute(
+ """
+ UPDATE events.ticket
+ SET paid = true
+ WHERE id = ?
+ """,
+ (payment_hash,),
+ )
+
+ eventdata = await get_event(row[2])
+ assert eventdata, "Couldn't get event from ticket being paid"
+
+ sold = eventdata.sold + 1
+ amount_tickets = eventdata.amount_tickets - 1
+ await db.execute(
+ """
+ UPDATE events.events
+ SET sold = ?, amount_tickets = ?
+ WHERE id = ?
+ """,
+ (sold, amount_tickets, row[2]),
+ )
+
+ ticket = await get_ticket(payment_hash)
+ assert ticket, "Newly updated ticket couldn't be retrieved"
+ return ticket
+
+
+async def get_ticket(payment_hash: str) -> Optional[Tickets]:
+ row = await db.fetchone("SELECT * FROM events.ticket WHERE id = ?", (payment_hash,))
+ return Tickets(**row) if row else None
+
+
+async def get_tickets(wallet_ids: Union[str, List[str]]) -> List[Tickets]:
+ if isinstance(wallet_ids, str):
+ wallet_ids = [wallet_ids]
+
+ q = ",".join(["?"] * len(wallet_ids))
+ rows = await db.fetchall(
+ f"SELECT * FROM events.ticket WHERE wallet IN ({q})", (*wallet_ids,)
+ )
+ return [Tickets(**row) for row in rows]
+
+
+async def delete_ticket(payment_hash: str) -> None:
+ await db.execute("DELETE FROM events.ticket WHERE id = ?", (payment_hash,))
+
+
+# EVENTS
+
+
+async def create_event(
+ data: CreateEvent
+) -> Events:
+ event_id = urlsafe_short_hash()
+ await db.execute(
+ """
+ INSERT INTO events.events (id, wallet, name, info, closing_date, event_start_date, event_end_date, amount_tickets, price_per_ticket, sold)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ """,
+ (
+ event_id,
+ data.wallet,
+ data.name,
+ data.info,
+ data.closing_date,
+ data.event_start_date,
+ data.event_end_date,
+ data.amount_tickets,
+ data.price_per_ticket,
+ 0,
+ ),
+ )
+
+ event = await get_event(event_id)
+ assert event, "Newly created event couldn't be retrieved"
+ return event
+
+
+async def update_event(event_id: str, **kwargs) -> Events:
+ q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
+ await db.execute(
+ f"UPDATE events.events SET {q} WHERE id = ?", (*kwargs.values(), event_id)
+ )
+ event = await get_event(event_id)
+ assert event, "Newly updated event couldn't be retrieved"
+ return event
+
+
+async def get_event(event_id: str) -> Optional[Events]:
+ row = await db.fetchone("SELECT * FROM events.events WHERE id = ?", (event_id,))
+ return Events(**row) if row else None
+
+
+async def get_events(wallet_ids: Union[str, List[str]]) -> List[Events]:
+ if isinstance(wallet_ids, str):
+ wallet_ids = [wallet_ids]
+
+ q = ",".join(["?"] * len(wallet_ids))
+ rows = await db.fetchall(
+ f"SELECT * FROM events.events WHERE wallet IN ({q})", (*wallet_ids,)
+ )
+
+ return [Events(**row) for row in rows]
+
+
+async def delete_event(event_id: str) -> None:
+ await db.execute("DELETE FROM events.events WHERE id = ?", (event_id,))
+
+
+# EVENTTICKETS
+
+
+async def get_event_tickets(event_id: str, wallet_id: str) -> List[Tickets]:
+ rows = await db.fetchall(
+ "SELECT * FROM events.ticket WHERE wallet = ? AND event = ?",
+ (wallet_id, event_id),
+ )
+ return [Tickets(**row) for row in rows]
+
+
+async def reg_ticket(ticket_id: str) -> List[Tickets]:
+ await db.execute(
+ "UPDATE events.ticket SET registered = ? WHERE id = ?", (True, ticket_id)
+ )
+ ticket = await db.fetchone("SELECT * FROM events.ticket WHERE id = ?", (ticket_id,))
+ rows = await db.fetchall(
+ "SELECT * FROM events.ticket WHERE event = ?", (ticket[1],)
+ )
+ return [Tickets(**row) for row in rows]
diff --git a/lnbits/extensions/events/migrations.py b/lnbits/extensions/events/migrations.py
new file mode 100644
index 00000000..d8f3d94e
--- /dev/null
+++ b/lnbits/extensions/events/migrations.py
@@ -0,0 +1,91 @@
+async def m001_initial(db):
+
+ await db.execute(
+ """
+ CREATE TABLE events.events (
+ id TEXT PRIMARY KEY,
+ wallet TEXT NOT NULL,
+ name TEXT NOT NULL,
+ info TEXT NOT NULL,
+ closing_date TEXT NOT NULL,
+ event_start_date TEXT NOT NULL,
+ event_end_date TEXT NOT NULL,
+ amount_tickets INTEGER NOT NULL,
+ price_per_ticket INTEGER NOT NULL,
+ sold INTEGER NOT NULL,
+ time TIMESTAMP NOT NULL DEFAULT """
+ + db.timestamp_now
+ + """
+ );
+ """
+ )
+
+ await db.execute(
+ """
+ CREATE TABLE events.tickets (
+ id TEXT PRIMARY KEY,
+ wallet TEXT NOT NULL,
+ event TEXT NOT NULL,
+ name TEXT NOT NULL,
+ email TEXT NOT NULL,
+ registered BOOLEAN NOT NULL,
+ time TIMESTAMP NOT NULL DEFAULT """
+ + db.timestamp_now
+ + """
+ );
+ """
+ )
+
+
+async def m002_changed(db):
+
+ await db.execute(
+ """
+ CREATE TABLE events.ticket (
+ id TEXT PRIMARY KEY,
+ wallet TEXT NOT NULL,
+ event TEXT NOT NULL,
+ name TEXT NOT NULL,
+ email TEXT NOT NULL,
+ registered BOOLEAN NOT NULL,
+ paid BOOLEAN NOT NULL,
+ time TIMESTAMP NOT NULL DEFAULT """
+ + db.timestamp_now
+ + """
+ );
+ """
+ )
+
+ for row in [list(row) for row in await db.fetchall("SELECT * FROM events.tickets")]:
+ usescsv = ""
+
+ for i in range(row[5]):
+ if row[7]:
+ usescsv += "," + str(i + 1)
+ else:
+ usescsv += "," + str(1)
+ usescsv = usescsv[1:]
+ await db.execute(
+ """
+ INSERT INTO events.ticket (
+ id,
+ wallet,
+ event,
+ name,
+ email,
+ registered,
+ paid
+ )
+ VALUES (?, ?, ?, ?, ?, ?, ?)
+ """,
+ (
+ row[0],
+ row[1],
+ row[2],
+ row[3],
+ row[4],
+ row[5],
+ True,
+ ),
+ )
+ await db.execute("DROP TABLE events.tickets")
diff --git a/lnbits/extensions/events/models.py b/lnbits/extensions/events/models.py
new file mode 100644
index 00000000..c775382f
--- /dev/null
+++ b/lnbits/extensions/events/models.py
@@ -0,0 +1,41 @@
+from fastapi.param_functions import Query
+from pydantic import BaseModel
+
+
+class CreateEvent(BaseModel):
+ wallet: str
+ name: str
+ info: str
+ closing_date: str
+ event_start_date: str
+ event_end_date: str
+ amount_tickets: int = Query(..., ge=0)
+ price_per_ticket: int = Query(..., ge=0)
+
+class CreateTicket(BaseModel):
+ name: str
+ email: str
+
+class Events(BaseModel):
+ id: str
+ wallet: str
+ name: str
+ info: str
+ closing_date: str
+ event_start_date: str
+ event_end_date: str
+ amount_tickets: int
+ price_per_ticket: int
+ sold: int
+ time: int
+
+
+class Tickets(BaseModel):
+ id: str
+ wallet: str
+ event: str
+ name: str
+ email: str
+ registered: bool
+ paid: bool
+ time: int
diff --git a/lnbits/extensions/events/templates/events/_api_docs.html b/lnbits/extensions/events/templates/events/_api_docs.html
new file mode 100644
index 00000000..a5c82174
--- /dev/null
+++ b/lnbits/extensions/events/templates/events/_api_docs.html
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+ Title: {% raw %} {{ copilot.title }} {% endraw %}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ + Events: Sell and register ticket waves for an event +
+
+ Events alows you to make a wave of tickets for an event, each ticket is
+ in the form of a unqiue QRcode, which the user presents at registration.
+ Events comes with a shareable ticket scanner, which can be used to
+ register attendees.
+
+ Created by, Ben Arc
+
+
+
+
+
+
+
+
+
+
+{% endblock %} {% block scripts %}
+
+{% endblock %}
diff --git a/lnbits/extensions/events/templates/events/error.html b/lnbits/extensions/events/templates/events/error.html
new file mode 100644
index 00000000..f231177b
--- /dev/null
+++ b/lnbits/extensions/events/templates/events/error.html
@@ -0,0 +1,35 @@
+{% extends "public.html" %} {% block page %}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{ event_name }}
++
{{ event_info }}
++
+ Submit
+ Cancel
+
+
+ Link to your ticket!
+
+
+ +
You'll be redirected in a few moments...
+
+
+
+
+
+
+
+ Copy invoice
+ Close
+
+
+
diff --git a/lnbits/extensions/events/templates/events/index.html b/lnbits/extensions/events/templates/events/index.html
new file mode 100644
index 00000000..c2d81960
--- /dev/null
+++ b/lnbits/extensions/events/templates/events/index.html
@@ -0,0 +1,538 @@
+{% extends "base.html" %} {% from "macros.jinja" import window_vars with context
+%} {% block page %}
+
+
+
+
+
+
+
+
+
+
+
+ {% endblock %} {% block scripts %}
+
+
+
+ {% endblock %}
+{{ event_name }} error
++
{{ event_error }}
++
+
+
+
+
+
+
+
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+
+{% endblock %}
diff --git a/lnbits/extensions/events/templates/events/register.html b/lnbits/extensions/events/templates/events/register.html
new file mode 100644
index 00000000..4dff9afb
--- /dev/null
+++ b/lnbits/extensions/events/templates/events/register.html
@@ -0,0 +1,173 @@
+{% extends "public.html" %} {% block page %}
+
+
+
+
+ New Event
+
+
+
+
+
+
+ {% raw %}
+
+
+
+ {{ col.label }}
+
+
+
+
+
+
+
+
+
+ {{ col.value }}
+
+
+
+
+
+
+
+ {% endraw %}
+
+
+
+
+
+
+
+ {% raw %}
+
+
+
+ {{ col.label }}
+
+
+
+
+
+
+
+
+
+ {{ col.value }}
+
+
+
+
+
+
+ {% endraw %}
+
+
+
+
+
+
+
+
+ Events
+
+ Export to CSV
+
+
+
+
+
+ Tickets
+
+ Export to CSV
+
+
+
+
+
+
+ {% include "events/_api_docs.html" %}
+
+
+
+
+ + {{SITE_TITLE}} Events extension +
+
+
+
+
+
+
+
+
+
+
+
+
+ Ticket closing date
+
+
+
+
+
+ Event begins
+
+
+
+
+
+ Event ends
+
+
+
+
+
+
+
+
+
+
+ Update Event
+ Create Event
+ Cancel
+
+
+
+
+
+
+
+{% endblock %} {% block scripts %}
+
+{% endblock %}
diff --git a/lnbits/extensions/events/templates/events/ticket.html b/lnbits/extensions/events/templates/events/ticket.html
new file mode 100644
index 00000000..a53f834f
--- /dev/null
+++ b/lnbits/extensions/events/templates/events/ticket.html
@@ -0,0 +1,45 @@
+{% extends "public.html" %} {% block page %}
+
+
+
+
+
+ +
+ +Scan ticket
+
+
+
+
+
+
+
+ {% raw %}
+
+
+
+ {{ col.label }}
+
+
+
+
+
+
+
+
+
+ {{ col.value }}
+
+
+
+ {% endraw %}
+
+
+
+
+
+ {{ event_name }} Registration
++ +
+ +
+
+
+ Cancel
+
+
+
+{% endblock %} {% block scripts %}
+
+{% endblock %}
diff --git a/lnbits/extensions/events/views.py b/lnbits/extensions/events/views.py
new file mode 100644
index 00000000..a80f7806
--- /dev/null
+++ b/lnbits/extensions/events/views.py
@@ -0,0 +1,107 @@
+from datetime import date, datetime
+from http import HTTPStatus
+
+from fastapi import Request
+from fastapi.params import Depends
+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
+
+from . import events_ext, events_renderer
+from .crud import get_event, get_ticket
+
+templates = Jinja2Templates(directory="templates")
+
+
+@events_ext.get("/", response_class=HTMLResponse)
+async def index(request: Request, user: User = Depends(check_user_exists)):
+ return events_renderer().TemplateResponse("events/index.html", {"request": request, "user": user.dict()})
+
+
+@events_ext.get("/{event_id}", response_class=HTMLResponse)
+async def display(request: Request, event_id):
+ event = await get_event(event_id)
+ if not event:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Event does not exist."
+ )
+
+ if event.amount_tickets < 1:
+ return events_renderer().TemplateResponse(
+ "events/error.html",
+ {
+ "request": request,
+ "event_name": event.name,
+ "event_error": "Sorry, tickets are sold out :("
+ }
+ )
+ datetime_object = datetime.strptime(event.closing_date, "%Y-%m-%d").date()
+ if date.today() > datetime_object:
+ return events_renderer().TemplateResponse(
+ "events/error.html",
+ {
+ "request": request,
+ "event_name": event.name,
+ "event_error": "Sorry, ticket closing date has passed :("
+ }
+ )
+
+ return events_renderer().TemplateResponse(
+ "events/display.html",
+ {
+ "request": request,
+ "event_id": event_id,
+ "event_name": event.name,
+ "event_info": event.info,
+ "event_price": event.price_per_ticket,
+ }
+
+ )
+
+
+@events_ext.get("/ticket/{ticket_id}", response_class=HTMLResponse)
+async def ticket(request: Request, ticket_id):
+ ticket = await get_ticket(ticket_id)
+ if not ticket:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Ticket does not exist."
+ )
+
+ event = await get_event(ticket.event)
+ if not event:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Event does not exist."
+ )
+
+ return events_renderer().TemplateResponse(
+ "events/ticket.html",
+ {
+ "request": request,
+ "ticket_id": ticket_id,
+ "ticket_name": event.name,
+ "ticket_info": event.info,
+
+ }
+ )
+
+
+@events_ext.get("/register/{event_id}", response_class=HTMLResponse)
+async def register(request: Request, event_id):
+ event = await get_event(event_id)
+ if not event:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Event does not exist."
+ )
+
+ return events_renderer().TemplateResponse(
+ "events/register.html",
+ {
+ "request": request,
+ "event_id": event_id,
+ "event_name": event.name,
+ "wallet_id": event.wallet,
+ }
+ )
diff --git a/lnbits/extensions/events/views_api.py b/lnbits/extensions/events/views_api.py
new file mode 100644
index 00000000..5dae31e1
--- /dev/null
+++ b/lnbits/extensions/events/views_api.py
@@ -0,0 +1,211 @@
+from http import HTTPStatus
+
+from fastapi.param_functions import Query
+from fastapi.params import Depends
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+
+from lnbits.core.crud import get_user, get_wallet
+from lnbits.core.services import check_invoice_status, create_invoice
+from lnbits.decorators import WalletTypeInfo, get_key_type
+from lnbits.extensions.events.models import CreateEvent, CreateTicket
+
+from . import events_ext
+from .crud import (
+ create_event,
+ create_ticket,
+ delete_event,
+ delete_ticket,
+ get_event,
+ get_event_tickets,
+ get_events,
+ get_ticket,
+ get_tickets,
+ reg_ticket,
+ set_ticket_paid,
+ update_event,
+)
+
+# Events
+
+
+@events_ext.get("/api/v1/events")
+async def api_events(
+ r: Request,
+ all_wallets: bool = Query(False),
+ wallet: WalletTypeInfo = Depends(get_key_type),
+):
+ wallet_ids = [wallet.wallet.id]
+
+ if all_wallets:
+ wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids
+
+ return [event.dict() for event in await get_events(wallet_ids)]
+
+@events_ext.post("/api/v1/events")
+@events_ext.put("/api/v1/events/{event_id}")
+async def api_event_create(data: CreateEvent, event_id=None, wallet: WalletTypeInfo = Depends(get_key_type)):
+ if event_id:
+ event = await get_event(event_id)
+ if not event:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND,
+ detail=f"Event does not exist."
+ )
+
+ if event.wallet != wallet.wallet.id:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN,
+ detail=f"Not your event."
+ )
+ event = await update_event(event_id, **data.dict())
+ else:
+ event = await create_event(data=data)
+
+ return event.dict()
+
+
+@events_ext.delete("/api/v1/events/{event_id}")
+async def api_form_delete(event_id, wallet: WalletTypeInfo = Depends(get_key_type)):
+ event = await get_event(event_id)
+ if not event:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND,
+ detail=f"Event does not exist."
+ )
+
+ if event.wallet != wallet.wallet.id:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN,
+ detail=f"Not your event."
+ )
+
+ await delete_event(event_id)
+ raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
+
+
+#########Tickets##########
+
+
+@events_ext.get("/api/v1/tickets")
+async def api_tickets(
+ r: Request,
+ all_wallets: bool = Query(False),
+ wallet: WalletTypeInfo = Depends(get_key_type),
+):
+ wallet_ids = [wallet.wallet.id]
+
+ if all_wallets:
+ wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids
+
+ return [ticket.dict() for ticket in await get_tickets(wallet_ids)]
+
+
+@events_ext.post("/api/v1/tickets/{event_id}/{sats}")
+async def api_ticket_make_ticket(event_id, sats, data: CreateTicket):
+ event = await get_event(event_id)
+ if not event:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND,
+ detail=f"Event does not exist."
+ )
+ try:
+ payment_hash, payment_request = await create_invoice(
+ wallet_id=event.wallet,
+ amount=int(sats),
+ memo=f"{event_id}",
+ extra={"tag": "events"},
+ )
+ except Exception as e:
+ raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(e))
+
+ ticket = await create_ticket(
+ payment_hash=payment_hash, wallet=event.wallet, event=event_id, name=data.name, email=data.email
+ )
+
+ if not ticket:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND,
+ detail=f"Event could not be fetched."
+ )
+
+ return {"payment_hash": payment_hash, "payment_request": payment_request}
+
+
+@events_ext.get("/api/v1/tickets/{payment_hash}")
+async def api_ticket_send_ticket(payment_hash):
+ ticket = await get_ticket(payment_hash)
+
+ try:
+ status = await check_invoice_status(ticket.wallet, payment_hash)
+ is_paid = not status.pending
+
+ except Exception:
+ raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Not paid")
+
+ if is_paid:
+ wallet = await get_wallet(ticket.wallet)
+ payment = await wallet.get_payment(payment_hash)
+ await payment.set_pending(False)
+ ticket = await set_ticket_paid(payment_hash=payment_hash)
+
+ return {"paid": True, "ticket_id": ticket.id}
+
+ return {"paid": False}
+
+
+@events_ext.delete("/api/v1/tickets/{ticket_id}")
+async def api_ticket_delete(ticket_id, wallet: WalletTypeInfo = Depends(get_key_type)):
+ ticket = await get_ticket(ticket_id)
+ if not ticket:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND,
+ detail=f"Ticket does not exist."
+ )
+
+ if ticket.wallet != wallet.wallet.id:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN,
+ detail=f"Not your ticket."
+ )
+
+ await delete_ticket(ticket_id)
+ raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
+
+
+
+# Event Tickets
+
+
+@events_ext.get("/api/v1/eventtickets/{wallet_id}/{event_id}")
+async def api_event_tickets(wallet_id, event_id):
+ return [
+ ticket.dict()
+ for ticket in await get_event_tickets(
+ wallet_id=wallet_id, event_id=event_id
+ )
+ ]
+
+
+@events_ext.get("/api/v1/register/ticket/{ticket_id}")
+async def api_event_register_ticket(ticket_id):
+ ticket = await get_ticket(ticket_id)
+ if not ticket:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND,
+ detail="Ticket does not exist."
+ )
+
+ if not ticket.paid:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN,
+ detail="Ticket not paid for."
+ )
+
+ if ticket.registered == True:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN,
+ detail="Ticket already registered"
+ )
+
+ return [ticket.dict() for ticket in await reg_ticket(ticket_id)]
diff --git a/lnbits/extensions/jukebox/README.md b/lnbits/extensions/jukebox/README.md
new file mode 100644
index 00000000..c761db44
--- /dev/null
+++ b/lnbits/extensions/jukebox/README.md
@@ -0,0 +1,36 @@
+# Jukebox
+
+## An actual Jukebox where users pay sats to play their favourite music from your playlists
+
+**Note:** To use this extension you need a Premium Spotify subscription.
+
+## Usage
+
+1. Click on "ADD SPOTIFY JUKEBOX"\
+ 
+2. Follow the steps required on the form\
+
+ - give your jukebox a name
+ - select a wallet to receive payment
+ - define the price a user must pay to select a song\
+ 
+ - follow the steps to get your Spotify App and get the client ID and secret key\
+ 
+ - paste the codes in the form\
+ 
+ - copy the _Redirect URL_ presented on the form\
+ 
+ - on Spotify click the "EDIT SETTINGS" button and paste the copied link in the _Redirect URI's_ prompt
+ 
+ - back on LNBits, click "AUTORIZE ACCESS" and "Agree" on the page that will open
+ - choose on which device the LNBits Jukebox extensions will stream to, you may have to be logged in in order to select the device (browser, smartphone app, etc...)
+ - and select what playlist will be available for users to choose songs (you need to have already playlist on Spotify)\
+ 
+
+3. After Jukebox is created, click the icon to open the dialog with the shareable QR, open the Jukebox page, etc...\
+ 
+4. The users will see the Jukebox page and choose a song from the selected playlist\
+ 
+5. After selecting a song they'd like to hear next a dialog will show presenting the music\
+ 
+6. After payment, the song will automatically start playing on the device selected or enter the queue if some other music is already playing
diff --git a/lnbits/extensions/jukebox/__init__.py b/lnbits/extensions/jukebox/__init__.py
new file mode 100644
index 00000000..0d4524a7
--- /dev/null
+++ b/lnbits/extensions/jukebox/__init__.py
@@ -0,0 +1,33 @@
+import asyncio
+from fastapi import APIRouter, FastAPI
+from fastapi.staticfiles import StaticFiles
+from starlette.routing import Mount
+from lnbits.db import Database
+from lnbits.helpers import template_renderer
+from lnbits.tasks import catch_everything_and_restart
+
+db = Database("ext_jukebox")
+
+jukebox_static_files = [
+ {
+ "path": "/jukebox/static",
+ "app": StaticFiles(directory="lnbits/extensions/jukebox/static"),
+ "name": "jukebox_static",
+ }
+]
+
+jukebox_ext: APIRouter = APIRouter(prefix="/jukebox", tags=["jukebox"])
+
+
+def jukebox_renderer():
+ return template_renderer(["lnbits/extensions/jukebox/templates"])
+
+
+from .views_api import * # noqa
+from .views import * # noqa
+from .tasks import wait_for_paid_invoices
+
+
+def jukebox_start():
+ loop = asyncio.get_event_loop()
+ loop.create_task(catch_everything_and_restart(wait_for_paid_invoices))
diff --git a/lnbits/extensions/jukebox/config.json b/lnbits/extensions/jukebox/config.json
new file mode 100644
index 00000000..6b57bec4
--- /dev/null
+++ b/lnbits/extensions/jukebox/config.json
@@ -0,0 +1,6 @@
+{
+ "name": "Spotify Jukebox",
+ "short_description": "Spotify jukebox middleware",
+ "icon": "radio",
+ "contributors": ["benarc"]
+}
diff --git a/lnbits/extensions/jukebox/crud.py b/lnbits/extensions/jukebox/crud.py
new file mode 100644
index 00000000..3f8ce96c
--- /dev/null
+++ b/lnbits/extensions/jukebox/crud.py
@@ -0,0 +1,111 @@
+from typing import List, Optional
+
+from . import db
+from .models import Jukebox, JukeboxPayment, CreateJukeLinkData, CreateJukeboxPayment
+from lnbits.helpers import urlsafe_short_hash
+
+
+async def create_jukebox(
+ data: CreateJukeLinkData, inkey: Optional[str] = ""
+) -> Jukebox:
+ juke_id = urlsafe_short_hash()
+ result = await db.execute(
+ """
+ INSERT INTO jukebox.jukebox (id, user, title, wallet, sp_user, sp_secret, sp_access_token, sp_refresh_token, sp_device, sp_playlists, price, profit)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ """,
+ (
+ juke_id,
+ data.user,
+ data.title,
+ data.wallet,
+ data.sp_user,
+ data.sp_secret,
+ data.sp_access_token,
+ data.sp_refresh_token,
+ data.sp_device,
+ data.sp_playlists,
+ data.price,
+ 0,
+ ),
+ )
+ jukebox = await get_jukebox(juke_id)
+ assert jukebox, "Newly created Jukebox couldn't be retrieved"
+ return jukebox
+
+
+async def update_jukebox(
+ data: CreateJukeLinkData, juke_id: Optional[str] = ""
+) -> Optional[Jukebox]:
+ q = ", ".join([f"{field[0]} = ?" for field in data])
+ items = [f"{field[1]}" for field in data]
+ items.append(juke_id)
+ print(q)
+ print(items)
+ await db.execute(f"UPDATE jukebox.jukebox SET {q} WHERE id = ?", (items))
+ row = await db.fetchone("SELECT * FROM jukebox.jukebox WHERE id = ?", (juke_id,))
+ return Jukebox(**row) if row else None
+
+
+async def get_jukebox(juke_id: str) -> Optional[Jukebox]:
+ row = await db.fetchone("SELECT * FROM jukebox.jukebox WHERE id = ?", (juke_id,))
+ return Jukebox(**row) if row else None
+
+
+async def get_jukebox_by_user(user: str) -> Optional[Jukebox]:
+ row = await db.fetchone("SELECT * FROM jukebox.jukebox WHERE sp_user = ?", (user,))
+ return Jukebox(**row) if row else None
+
+
+async def get_jukeboxs(user: str) -> List[Jukebox]:
+ rows = await db.fetchall("SELECT * FROM jukebox.jukebox WHERE user = ?", (user,))
+ for row in rows:
+ if row.sp_playlists == None:
+ print("cunt")
+ await delete_jukebox(row.id)
+ rows = await db.fetchall("SELECT * FROM jukebox.jukebox WHERE user = ?", (user,))
+
+ return [Jukebox(**row) for row in rows]
+
+
+async def delete_jukebox(juke_id: str):
+ await db.execute(
+ """
+ DELETE FROM jukebox.jukebox WHERE id = ?
+ """,
+ (juke_id),
+ )
+
+
+#####################################PAYMENTS
+
+
+async def create_jukebox_payment(data: CreateJukeboxPayment) -> JukeboxPayment:
+ result = await db.execute(
+ """
+ INSERT INTO jukebox.jukebox_payment (payment_hash, juke_id, song_id, paid)
+ VALUES (?, ?, ?, ?)
+ """,
+ (data.payment_hash, data.juke_id, data.song_id, False),
+ )
+ jukebox_payment = await get_jukebox_payment(data.payment_hash)
+ assert jukebox_payment, "Newly created Jukebox Payment couldn't be retrieved"
+ return jukebox_payment
+
+
+async def update_jukebox_payment(
+ payment_hash: str, **kwargs
+) -> Optional[JukeboxPayment]:
+ q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
+ await db.execute(
+ f"UPDATE jukebox.jukebox_payment SET {q} WHERE payment_hash = ?",
+ (*kwargs.values(), payment_hash),
+ )
+ return await get_jukebox_payment(payment_hash)
+
+
+async def get_jukebox_payment(payment_hash: str) -> Optional[JukeboxPayment]:
+ row = await db.fetchone(
+ "SELECT * FROM jukebox.jukebox_payment WHERE payment_hash = ?", (payment_hash,)
+ )
+ return JukeboxPayment(**row) if row else None
diff --git a/lnbits/extensions/jukebox/migrations.py b/lnbits/extensions/jukebox/migrations.py
new file mode 100644
index 00000000..a0a3bd28
--- /dev/null
+++ b/lnbits/extensions/jukebox/migrations.py
@@ -0,0 +1,39 @@
+async def m001_initial(db):
+ """
+ Initial jukebox table.
+ """
+ await db.execute(
+ """
+ CREATE TABLE jukebox.jukebox (
+ id TEXT PRIMARY KEY,
+ "user" TEXT,
+ title TEXT,
+ wallet TEXT,
+ inkey TEXT,
+ sp_user TEXT NOT NULL,
+ sp_secret TEXT NOT NULL,
+ sp_access_token TEXT,
+ sp_refresh_token TEXT,
+ sp_device TEXT,
+ sp_playlists TEXT,
+ price INTEGER,
+ profit INTEGER
+ );
+ """
+ )
+
+
+async def m002_initial(db):
+ """
+ Initial jukebox_payment table.
+ """
+ await db.execute(
+ """
+ CREATE TABLE jukebox.jukebox_payment (
+ payment_hash TEXT PRIMARY KEY,
+ juke_id TEXT,
+ song_id TEXT,
+ paid BOOL
+ );
+ """
+ )
diff --git a/lnbits/extensions/jukebox/models.py b/lnbits/extensions/jukebox/models.py
new file mode 100644
index 00000000..093961e4
--- /dev/null
+++ b/lnbits/extensions/jukebox/models.py
@@ -0,0 +1,50 @@
+from typing import NamedTuple
+from sqlite3 import Row
+from fastapi.param_functions import Query
+from pydantic.main import BaseModel
+from pydantic import BaseModel
+from typing import Optional
+
+
+class CreateJukeLinkData(BaseModel):
+ user: str = Query(None)
+ title: str = Query(None)
+ wallet: str = Query(None)
+ sp_user: str = Query(None)
+ sp_secret: str = Query(None)
+ sp_access_token: str = Query(None)
+ sp_refresh_token: str = Query(None)
+ sp_device: str = Query(None)
+ sp_playlists: str = Query(None)
+ price: str = Query(None)
+
+
+class Jukebox(BaseModel):
+ id: Optional[str]
+ user: Optional[str]
+ title: Optional[str]
+ wallet: Optional[str]
+ inkey: Optional[str]
+ sp_user: Optional[str]
+ sp_secret: Optional[str]
+ sp_access_token: Optional[str]
+ sp_refresh_token: Optional[str]
+ sp_device: Optional[str]
+ sp_playlists: Optional[str]
+ price: Optional[int]
+ profit: Optional[int]
+
+
+class JukeboxPayment(BaseModel):
+ payment_hash: str
+ juke_id: str
+ song_id: str
+ paid: bool
+
+
+class CreateJukeboxPayment(BaseModel):
+ invoice: str = Query(None)
+ payment_hash: str = Query(None)
+ juke_id: str = Query(None)
+ song_id: str = Query(None)
+ paid: bool = Query(False)
diff --git a/lnbits/extensions/jukebox/static/js/index.js b/lnbits/extensions/jukebox/static/js/index.js
new file mode 100644
index 00000000..049b600e
--- /dev/null
+++ b/lnbits/extensions/jukebox/static/js/index.js
@@ -0,0 +1,415 @@
+/* globals Quasar, Vue, _, VueQrcode, windowMixin, LNbits, LOCALE */
+
+Vue.component(VueQrcode.name, VueQrcode)
+
+var mapJukebox = obj => {
+ if(obj.sp_device){
+ obj._data = _.clone(obj)
+
+ obj.sp_id = obj._data.id
+ obj.device = obj._data.sp_device.split('-')[0]
+ playlists = obj._data.sp_playlists.split(',')
+ var i
+ playlistsar = []
+ for (i = 0; i < playlists.length; i++) {
+ playlistsar.push(playlists[i].split('-')[0])
+ }
+ obj.playlist = playlistsar.join()
+ console.log(obj)
+ return obj
+ }
+ else {
+ return
+ }
+
+}
+
+new Vue({
+ el: '#vue',
+ mixins: [windowMixin],
+ data() {
+ return {
+ JukeboxTable: {
+ columns: [
+ {
+ name: 'title',
+ align: 'left',
+ label: 'Title',
+ field: 'title'
+ },
+ {
+ name: 'device',
+ align: 'left',
+ label: 'Device',
+ field: 'device'
+ },
+ {
+ name: 'playlist',
+ align: 'left',
+ label: 'Playlist',
+ field: 'playlist'
+ },
+ {
+ name: 'price',
+ align: 'left',
+ label: 'Price',
+ field: 'price'
+ }
+ ],
+ pagination: {
+ rowsPerPage: 10
+ }
+ },
+ isPwd: true,
+ tokenFetched: true,
+ devices: [],
+ filter: '',
+ jukebox: {},
+ playlists: [],
+ JukeboxLinks: [],
+ step: 1,
+ locationcbPath: '',
+ locationcb: '',
+ jukeboxDialog: {
+ show: false,
+ data: {}
+ },
+ spotifyDialog: false,
+ qrCodeDialog: {
+ show: false,
+ data: null
+ }
+ }
+ },
+ computed: {},
+ methods: {
+ openQrCodeDialog: function (linkId) {
+ var link = _.findWhere(this.JukeboxLinks, {id: linkId})
+
+ this.qrCodeDialog.data = _.clone(link)
+
+ this.qrCodeDialog.data.url =
+ window.location.protocol + '//' + window.location.host
+ this.qrCodeDialog.show = true
+ },
+ getJukeboxes() {
+ self = this
+
+ LNbits.api
+ .request(
+ 'GET',
+ '/jukebox/api/v1/jukebox',
+ self.g.user.wallets[0].adminkey
+ )
+ .then(function (response) {
+ self.JukeboxLinks = response.data.map(function (obj) {
+
+ return mapJukebox(obj)
+ })
+ console.log(self.JukeboxLinks)
+ })
+ },
+ deleteJukebox(juke_id) {
+ self = this
+ LNbits.utils
+ .confirmDialog('Are you sure you want to delete this Jukebox?')
+ .onOk(function () {
+ LNbits.api
+ .request(
+ 'DELETE',
+ '/jukebox/api/v1/jukebox/' + juke_id,
+ self.g.user.wallets[0].adminkey
+ )
+ .then(function (response) {
+ self.JukeboxLinks = _.reject(self.JukeboxLinks, function (obj) {
+ return obj.id === juke_id
+ })
+ })
+
+ .catch(err => {
+ LNbits.utils.notifyApiError(err)
+ })
+ })
+ },
+ updateJukebox: function (linkId) {
+ self = this
+ var link = _.findWhere(self.JukeboxLinks, {id: linkId})
+ self.jukeboxDialog.data = _.clone(link._data)
+
+ self.refreshDevices()
+ self.refreshPlaylists()
+
+ self.step = 4
+ self.jukeboxDialog.data.sp_device = []
+ self.jukeboxDialog.data.sp_playlists = []
+ self.jukeboxDialog.data.sp_id = self.jukeboxDialog.data.id
+ self.jukeboxDialog.data.price = String(self.jukeboxDialog.data.price)
+ self.jukeboxDialog.show = true
+ },
+ closeFormDialog() {
+ this.jukeboxDialog.data = {}
+ this.jukeboxDialog.show = false
+ this.step = 1
+ },
+ submitSpotifyKeys() {
+ self = this
+ self.jukeboxDialog.data.user = self.g.user.id
+
+ LNbits.api
+ .request(
+ 'POST',
+ '/jukebox/api/v1/jukebox/',
+ self.g.user.wallets[0].adminkey,
+ self.jukeboxDialog.data
+ )
+ .then(response => {
+ if (response.data) {
+ self.jukeboxDialog.data.sp_id = response.data.id
+ self.step = 3
+ }
+ })
+ .catch(err => {
+ LNbits.utils.notifyApiError(err)
+ })
+ },
+ authAccess() {
+ self = this
+ self.requestAuthorization()
+ self.getSpotifyTokens()
+ self.$q.notify({
+ spinner: true,
+ message: 'Processing',
+ timeout: 10000
+ })
+ },
+ getSpotifyTokens() {
+ self = this
+ var counter = 0
+ var timerId = setInterval(function () {
+ counter++
+ if (!self.jukeboxDialog.data.sp_user) {
+ clearInterval(timerId)
+ }
+ LNbits.api
+ .request(
+ 'GET',
+ '/jukebox/api/v1/jukebox/' + self.jukeboxDialog.data.sp_id,
+ self.g.user.wallets[0].adminkey
+ )
+ .then(response => {
+ if (response.data.sp_access_token) {
+ self.fetchAccessToken(response.data.sp_access_token)
+ if (self.jukeboxDialog.data.sp_access_token) {
+ self.refreshPlaylists()
+ self.refreshDevices()
+ setTimeout(function () {
+ if (self.devices.length < 1 || self.playlists.length < 1) {
+ self.$q.notify({
+ spinner: true,
+ color: 'red',
+ message:
+ 'Error! Make sure Spotify is open on the device you wish to use, has playlists, and is playing something',
+ timeout: 10000
+ })
+ LNbits.api
+ .request(
+ 'DELETE',
+ '/jukebox/api/v1/jukebox/' + response.data.id,
+ self.g.user.wallets[0].adminkey
+ )
+ .then(function (response) {
+ self.getJukeboxes()
+ })
+ .catch(err => {
+ LNbits.utils.notifyApiError(err)
+ })
+ clearInterval(timerId)
+ self.closeFormDialog()
+ } else {
+ self.step = 4
+ clearInterval(timerId)
+ }
+ }, 2000)
+ }
+ }
+ })
+ .catch(err => {
+ LNbits.utils.notifyApiError(err)
+ })
+ }, 3000)
+ },
+ requestAuthorization() {
+ self = this
+ var url = 'https://accounts.spotify.com/authorize'
+ url += '?client_id=' + self.jukeboxDialog.data.sp_user
+ url += '&response_type=code'
+ url +=
+ '&redirect_uri=' +
+ encodeURI(self.locationcbPath + self.jukeboxDialog.data.sp_id)
+ url += '&show_dialog=true'
+ url +=
+ '&scope=user-read-private user-read-email user-modify-playback-state user-read-playback-position user-library-read streaming user-read-playback-state user-read-recently-played playlist-read-private'
+
+ window.open(url)
+ },
+ openNewDialog() {
+ this.jukeboxDialog.show = true
+ this.jukeboxDialog.data = {}
+ },
+ createJukebox() {
+ self = this
+ self.jukeboxDialog.data.sp_playlists = self.jukeboxDialog.data.sp_playlists.join()
+ self.updateDB()
+ self.jukeboxDialog.show = false
+ self.getJukeboxes()
+ },
+ updateDB() {
+ self = this
+ LNbits.api
+ .request(
+ 'PUT',
+ '/jukebox/api/v1/jukebox/' + self.jukeboxDialog.data.sp_id,
+ self.g.user.wallets[0].adminkey,
+ self.jukeboxDialog.data
+ )
+ .then(function (response) {
+ if (
+ self.jukeboxDialog.data.sp_playlists &&
+ self.jukeboxDialog.data.sp_devices
+ ) {
+ self.getJukeboxes()
+ // self.JukeboxLinks.push(mapJukebox(response.data))
+ }
+ })
+ },
+ playlistApi(method, url, body) {
+ self = this
+ let xhr = new XMLHttpRequest()
+ xhr.open(method, url, true)
+ xhr.setRequestHeader('Content-Type', 'application/json')
+ xhr.setRequestHeader(
+ 'Authorization',
+ 'Bearer ' + this.jukeboxDialog.data.sp_access_token
+ )
+ xhr.send(body)
+ xhr.onload = function () {
+ if (xhr.status == 401) {
+ self.refreshAccessToken()
+ self.playlistApi(
+ 'GET',
+ 'https://api.spotify.com/v1/me/playlists',
+ null
+ )
+ }
+ let responseObj = JSON.parse(xhr.response)
+ self.jukeboxDialog.data.playlists = null
+ self.playlists = []
+ self.jukeboxDialog.data.playlists = []
+ var i
+ for (i = 0; i < responseObj.items.length; i++) {
+ self.playlists.push(
+ responseObj.items[i].name + '-' + responseObj.items[i].id
+ )
+ }
+ }
+ },
+ refreshPlaylists() {
+ self = this
+ self.playlistApi('GET', 'https://api.spotify.com/v1/me/playlists', null)
+ },
+ deviceApi(method, url, body) {
+ self = this
+ let xhr = new XMLHttpRequest()
+ xhr.open(method, url, true)
+ xhr.setRequestHeader('Content-Type', 'application/json')
+ xhr.setRequestHeader(
+ 'Authorization',
+ 'Bearer ' + this.jukeboxDialog.data.sp_access_token
+ )
+ xhr.send(body)
+ xhr.onload = function () {
+ if (xhr.status == 401) {
+ self.refreshAccessToken()
+ self.deviceApi(
+ 'GET',
+ 'https://api.spotify.com/v1/me/player/devices',
+ null
+ )
+ }
+ let responseObj = JSON.parse(xhr.response)
+ self.jukeboxDialog.data.devices = []
+
+ self.devices = []
+ var i
+ for (i = 0; i < responseObj.devices.length; i++) {
+ self.devices.push(
+ responseObj.devices[i].name + '-' + responseObj.devices[i].id
+ )
+ }
+ }
+ },
+ refreshDevices() {
+ self = this
+ self.deviceApi(
+ 'GET',
+ 'https://api.spotify.com/v1/me/player/devices',
+ null
+ )
+ },
+ fetchAccessToken(code) {
+ self = this
+ let body = 'grant_type=authorization_code'
+ body += '&code=' + code
+ body +=
+ '&redirect_uri=' +
+ encodeURI(self.locationcbPath + self.jukeboxDialog.data.sp_id)
+
+ self.callAuthorizationApi(body)
+ },
+ refreshAccessToken() {
+ self = this
+ let body = 'grant_type=refresh_token'
+ body += '&refresh_token=' + self.jukeboxDialog.data.sp_refresh_token
+ body += '&client_id=' + self.jukeboxDialog.data.sp_user
+ self.callAuthorizationApi(body)
+ },
+ callAuthorizationApi(body) {
+ self = this
+ let xhr = new XMLHttpRequest()
+ xhr.open('POST', 'https://accounts.spotify.com/api/token', true)
+ xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded')
+ xhr.setRequestHeader(
+ 'Authorization',
+ 'Basic ' +
+ btoa(
+ self.jukeboxDialog.data.sp_user +
+ ':' +
+ self.jukeboxDialog.data.sp_secret
+ )
+ )
+ xhr.send(body)
+ xhr.onload = function () {
+ let responseObj = JSON.parse(xhr.response)
+ if (responseObj.access_token) {
+ self.jukeboxDialog.data.sp_access_token = responseObj.access_token
+ self.jukeboxDialog.data.sp_refresh_token = responseObj.refresh_token
+ self.updateDB()
+ }
+ }
+ }
+ },
+ created() {
+ var getJukeboxes = this.getJukeboxes
+ getJukeboxes()
+ this.selectedWallet = this.g.user.wallets[0]
+ this.locationcbPath = String(
+ [
+ window.location.protocol,
+ '//',
+ window.location.host,
+ '/jukebox/api/v1/jukebox/spotify/cb/'
+ ].join('')
+ )
+ this.locationcb = this.locationcbPath
+ }
+})
diff --git a/lnbits/extensions/jukebox/static/spotapi.gif b/lnbits/extensions/jukebox/static/spotapi.gif
new file mode 100644
index 00000000..023efc9a
Binary files /dev/null and b/lnbits/extensions/jukebox/static/spotapi.gif differ
diff --git a/lnbits/extensions/jukebox/static/spotapi1.gif b/lnbits/extensions/jukebox/static/spotapi1.gif
new file mode 100644
index 00000000..478032c5
Binary files /dev/null and b/lnbits/extensions/jukebox/static/spotapi1.gif differ
diff --git a/lnbits/extensions/jukebox/tasks.py b/lnbits/extensions/jukebox/tasks.py
new file mode 100644
index 00000000..52366bea
--- /dev/null
+++ b/lnbits/extensions/jukebox/tasks.py
@@ -0,0 +1,25 @@
+import asyncio
+import json
+import httpx
+
+from lnbits.core import db as core_db
+from lnbits.core.models import Payment
+from lnbits.tasks import register_invoice_listener
+
+from .crud import get_jukebox, update_jukebox_payment
+
+
+async def wait_for_paid_invoices():
+ invoice_queue = asyncio.Queue()
+ register_invoice_listener(invoice_queue)
+
+ while True:
+ payment = await invoice_queue.get()
+ await on_invoice_paid(payment)
+
+
+async def on_invoice_paid(payment: Payment) -> None:
+ if "jukebox" != payment.extra.get("tag"):
+ # not a jukebox invoice
+ return
+ await update_jukebox_payment(payment.payment_hash, paid=True)
diff --git a/lnbits/extensions/jukebox/templates/jukebox/_api_docs.html b/lnbits/extensions/jukebox/templates/jukebox/_api_docs.html
new file mode 100644
index 00000000..b1968b48
--- /dev/null
+++ b/lnbits/extensions/jukebox/templates/jukebox/_api_docs.html
@@ -0,0 +1,125 @@
+
+
+
+
+
+
+ Bookmark, print or screenshot this page,
+
+ +
+
+
+
+
+
+
+{{ ticket_name }} Ticket
++
+ Bookmark, print or screenshot this page,
+ and present it for registration!
+
+ + +
+
Select the playlists you want people to be able to pay for, share + the frontend page, profit :)
+ Made by, + benarc. + Inspired by, + pirosb3. +
GET /jukebox/api/v1/jukebox
+ Headers
+{"X-Api-Key": <admin_key>}+
Body (application/json)
++ Returns 200 OK (application/json) +
+[<jukebox_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/jukebox -H "X-Api-Key: {{
+ user.wallets[0].adminkey }}"
+
+ GET
+ /jukebox/api/v1/jukebox/<juke_id>
+ Headers
+{"X-Api-Key": <admin_key>}+
Body (application/json)
++ Returns 200 OK (application/json) +
+<jukebox_object>
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/jukebox/<juke_id> -H
+ "X-Api-Key: {{ user.wallets[0].adminkey }}"
+
+ POST/PUT
+ /jukebox/api/v1/jukebox/
+ Headers
+{"X-Api-Key": <admin_key>}+
Body (application/json)
++ Returns 200 OK (application/json) +
+<jukbox_object>
+ Curl example
+curl -X POST {{ request.url_root }}api/v1/jukebox/ -d '{"user":
+ <string, user_id>, "title": <string>,
+ "wallet":<string>, "sp_user": <string,
+ spotify_user_account>, "sp_secret": <string,
+ spotify_user_secret>, "sp_access_token": <string,
+ not_required>, "sp_refresh_token": <string, not_required>,
+ "sp_device": <string, spotify_user_secret>, "sp_playlists":
+ <string, not_required>, "price": <integer, not_required>}'
+ -H "Content-type: application/json" -H "X-Api-Key:
+ {{user.wallets[0].adminkey }}"
+
+ DELETE
+ /jukebox/api/v1/jukebox/<juke_id>
+ Headers
+{"X-Api-Key": <admin_key>}+
Body (application/json)
++ Returns 200 OK (application/json) +
+<jukebox_object>
+ Curl example
+curl -X DELETE {{ request.url_root }}api/v1/jukebox/<juke_id>
+ -H "X-Api-Key: {{ user.wallets[0].adminkey }}"
+
+
+
diff --git a/lnbits/extensions/jukebox/templates/jukebox/index.html b/lnbits/extensions/jukebox/templates/jukebox/index.html
new file mode 100644
index 00000000..9b4efbd5
--- /dev/null
+++ b/lnbits/extensions/jukebox/templates/jukebox/index.html
@@ -0,0 +1,368 @@
+{% extends "base.html" %} {% from "macros.jinja" import window_vars with context
+%} {% block page %}
+
+
+
+
+
+
+
+
+
+
+
+ {% endblock %} {% block scripts %}
+
+
+
+ {% endblock %}
+Jukebox error
++
+ Ask the host to turn on the device and launch spotify +
++
+
+
+
+
+
+
+
+
+
+
+ 
+ To use this extension you need a Spotify client ID and client secret.
+ You get these by creating an app in the Spotify developers dashboard
+ here.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ In the app go to edit-settings, set the redirect URI to this link
+
+{% raw %}{{ locationcb }}{{ jukeboxDialog.data.sp_id }}{% endraw
+ %} Click to copy URL
+
+
+ Settings can be found + here. + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+
+
+{% endblock %}
diff --git a/lnbits/extensions/jukebox/templates/jukebox/jukebox.html b/lnbits/extensions/jukebox/templates/jukebox/jukebox.html
new file mode 100644
index 00000000..2791f09e
--- /dev/null
+++ b/lnbits/extensions/jukebox/templates/jukebox/jukebox.html
@@ -0,0 +1,281 @@
+{% extends "public.html" %} {% block page %}
+
+
+
+ Add Spotify Jukebox
+
+ {% raw %}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Jukebox QR
+
+
+
+
+ Delete Jukebox
+
+
+
+
+
+
+
+
+ {% endraw %}
+
+
+
+
+ {{ col.label }}
+ {{ col.value }}
+
+
+
+
+
+ {% include "jukebox/_api_docs.html" %}
+
+
+
+
+ + {{SITE_TITLE}} jukebox extension +
+
+
+
+
+ Continue
+ Continue
+
+
+ Cancel
+
+ +
+ To use this extension you need a Spotify client ID and client secret.
+ You get these by creating an app in the Spotify developers dashboard
+ here.
+
+
+
+
+ Submit keys
+ Submit keys
+
+
+ Cancel
+
+ +
+ In the app go to edit-settings, set the redirect URI to this link
+ +
+ Settings can be found + here. + +
+
+
+
+ Authorise access
+ Authorise access
+
+
+ Cancel
+
+ +
+
+
+ Create Jukebox
+ Create Jukebox
+
+
+ Cancel
+
+ Shareable Jukebox QR
+
+
+ Copy jukebox link
+ Open jukebox
+ Close
+
+
+
+{% endblock %} {% block scripts %}
+
+{% endblock %}
diff --git a/lnbits/extensions/jukebox/views.py b/lnbits/extensions/jukebox/views.py
new file mode 100644
index 00000000..dec65eb9
--- /dev/null
+++ b/lnbits/extensions/jukebox/views.py
@@ -0,0 +1,52 @@
+from http import HTTPStatus
+
+from fastapi import Request
+from fastapi.params import Depends
+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 WalletTypeInfo, check_user_exists, get_key_type
+
+from . import jukebox_ext, jukebox_renderer
+from .crud import get_jukebox
+from .views_api import api_get_jukebox_device_check
+
+templates = Jinja2Templates(directory="templates")
+
+
+@jukebox_ext.get("/", response_class=HTMLResponse)
+async def index(request: Request, user: User = Depends(check_user_exists)):
+ return jukebox_renderer().TemplateResponse(
+ "jukebox/index.html", {"request": request, "user": user.dict()}
+ )
+
+
+@jukebox_ext.get("/{juke_id}", response_class=HTMLResponse)
+async def connect_to_jukebox(request: Request, juke_id):
+ jukebox = await get_jukebox(juke_id)
+ if not jukebox:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Jukebox does not exist."
+ )
+ devices = await api_get_jukebox_device_check(juke_id)
+ for device in devices["devices"]:
+ if device["id"] == jukebox.sp_device.split("-")[1]:
+ deviceConnected = True
+ if deviceConnected:
+ return jukebox_renderer().TemplateResponse(
+ "jukebox/jukebox.html",
+ {
+ "request": request,
+ "playlists": jukebox.sp_playlists.split(","),
+ "juke_id": juke_id,
+ "price": jukebox.price,
+ "inkey": jukebox.inkey,
+ },
+ )
+ else:
+ return jukebox_renderer().TemplateResponse(
+ "jukebox/error.html",
+ {"request": request, "jukebox": jukebox.jukebox(req=request)},
+ )
diff --git a/lnbits/extensions/jukebox/views_api.py b/lnbits/extensions/jukebox/views_api.py
new file mode 100644
index 00000000..e6403d00
--- /dev/null
+++ b/lnbits/extensions/jukebox/views_api.py
@@ -0,0 +1,463 @@
+import base64
+import json
+from http import HTTPStatus
+
+import httpx
+from fastapi import Request
+from fastapi.param_functions import Query
+from fastapi.params import Depends
+from starlette.exceptions import HTTPException
+from starlette.responses import HTMLResponse, JSONResponse # type: ignore
+
+from lnbits.core.crud import get_wallet
+from lnbits.core.services import check_invoice_status, create_invoice
+from lnbits.decorators import WalletTypeInfo, get_key_type
+
+from . import jukebox_ext
+from .crud import (
+ create_jukebox,
+ create_jukebox_payment,
+ delete_jukebox,
+ get_jukebox,
+ get_jukebox_payment,
+ get_jukeboxs,
+ update_jukebox,
+ update_jukebox_payment,
+)
+from .models import CreateJukeboxPayment, CreateJukeLinkData
+
+
+@jukebox_ext.get("/api/v1/jukebox")
+async def api_get_jukeboxs(
+ req: Request,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ all_wallets: bool = Query(False),
+):
+ wallet_user = wallet.wallet.user
+
+ try:
+ jukeboxs = [jukebox.dict() for jukebox in await get_jukeboxs(wallet_user)]
+ return jukeboxs
+
+ except:
+ raise HTTPException(status_code=HTTPStatus.NO_CONTENT, detail="No Jukeboxes")
+
+
+##################SPOTIFY AUTH#####################
+
+
+@jukebox_ext.get("/api/v1/jukebox/spotify/cb/{juke_id}", response_class=HTMLResponse)
+async def api_check_credentials_callbac(
+ juke_id: str = Query(None),
+ code: str = Query(None),
+ access_token: str = Query(None),
+ refresh_token: str = Query(None),
+):
+ sp_code = ""
+ sp_access_token = ""
+ sp_refresh_token = ""
+ try:
+ jukebox = await get_jukebox(juke_id)
+ except:
+ raise HTTPException(detail="No Jukebox", status_code=HTTPStatus.FORBIDDEN)
+ if code:
+ jukebox.sp_access_token = code
+ jukebox = await update_jukebox(jukebox, juke_id=juke_id)
+ if access_token:
+ jukebox.sp_access_token = access_token
+ jukebox.sp_refresh_token = refresh_token
+ jukebox = await update_jukebox(jukebox, juke_id=juke_id)
+ return "
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {% raw %} {{ item.name }} - ({{ item.artist }}){% endraw %}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Currently playing
+
+
+
+ ![]()
+
+
+ {% raw %}
+ {{ currentPlay.name }}
+ {{ currentPlay.artist }} +
+ {% endraw %}
+ + {{ currentPlay.artist }} +
Pick a song
+
+
+
+ ![]()
+
+
+ {% raw %}
+ {{ receive.name }}
+ {{ receive.artist }} +
+ + {{ receive.artist }} +
+
+ Play for {% endraw %}{{ price }}sats
+
+
+
+ Copy invoice
+
+ Success!
You can close this window
" + + +@jukebox_ext.get("/api/v1/jukebox/{juke_id}") +async def api_check_credentials_check( + juke_id: str = Query(None), wallet: WalletTypeInfo = Depends(get_key_type) +): + print(juke_id) + jukebox = await get_jukebox(juke_id) + + return jukebox + + +@jukebox_ext.post("/api/v1/jukebox", status_code=HTTPStatus.CREATED) +@jukebox_ext.put("/api/v1/jukebox/{juke_id}", status_code=HTTPStatus.OK) +async def api_create_update_jukebox( + data: CreateJukeLinkData, + juke_id: str = Query(None), + wallet: WalletTypeInfo = Depends(get_key_type), +): + if juke_id: + jukebox = await update_jukebox(data, juke_id=juke_id) + else: + jukebox = await create_jukebox(data, inkey=wallet.wallet.inkey) + return jukebox + + +@jukebox_ext.delete("/api/v1/jukebox/{juke_id}") +async def api_delete_item(juke_id=None, wallet: WalletTypeInfo = Depends(get_key_type)): + await delete_jukebox(juke_id) + try: + return [{**jukebox} for jukebox in await get_jukeboxs(wallet.wallet.user)] + except: + raise HTTPException(status_code=HTTPStatus.NO_CONTENT, detail="No Jukebox") + + +################JUKEBOX ENDPOINTS################## + +######GET ACCESS TOKEN###### + + +@jukebox_ext.get("/api/v1/jukebox/jb/playlist/{juke_id}/{sp_playlist}") +async def api_get_jukebox_song( + juke_id: str = Query(None), + sp_playlist: str = Query(None), + retry: bool = Query(False), +): + try: + jukebox = await get_jukebox(juke_id) + except: + raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="No Jukeboxes") + tracks = [] + async with httpx.AsyncClient() as client: + try: + r = await client.get( + "https://api.spotify.com/v1/playlists/" + sp_playlist + "/tracks", + timeout=40, + headers={"Authorization": "Bearer " + jukebox.sp_access_token}, + ) + if "items" not in r.json(): + if r.status_code == 401: + token = await api_get_token(juke_id) + if token == False: + return False + elif retry: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, + detail="Failed to get auth", + ) + else: + return await api_get_jukebox_song( + juke_id, sp_playlist, retry=True + ) + return r + for item in r.json()["items"]: + tracks.append( + { + "id": item["track"]["id"], + "name": item["track"]["name"], + "album": item["track"]["album"]["name"], + "artist": item["track"]["artists"][0]["name"], + "image": item["track"]["album"]["images"][0]["url"], + } + ) + except: + something = None + return [track for track in tracks] + + +async def api_get_token(juke_id=None): + try: + jukebox = await get_jukebox(juke_id) + except: + raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="No Jukeboxes") + + async with httpx.AsyncClient() as client: + try: + r = await client.post( + "https://accounts.spotify.com/api/token", + timeout=40, + params={ + "grant_type": "refresh_token", + "refresh_token": jukebox.sp_refresh_token, + "client_id": jukebox.sp_user, + }, + headers={ + "Content-Type": "application/x-www-form-urlencoded", + "Authorization": "Basic " + + base64.b64encode( + str(jukebox.sp_user + ":" + jukebox.sp_secret).encode("ascii") + ).decode("ascii"), + "Content-Type": "application/x-www-form-urlencoded", + }, + ) + if "access_token" not in r.json(): + return False + else: + jukebox.sp_access_token = r.json()["access_token"] + await update_jukebox(jukebox, juke_id=juke_id) + except: + something = None + return True + + +######CHECK DEVICE + + +@jukebox_ext.get("/api/v1/jukebox/jb/{juke_id}") +async def api_get_jukebox_device_check( + juke_id: str = Query(None), retry: bool = Query(False) +): + try: + jukebox = await get_jukebox(juke_id) + except: + raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="No Jukeboxes") + async with httpx.AsyncClient() as client: + rDevice = await client.get( + "https://api.spotify.com/v1/me/player/devices", + timeout=40, + headers={"Authorization": "Bearer " + jukebox.sp_access_token}, + ) + if rDevice.status_code == 204 or rDevice.status_code == 200: + return json.loads(rDevice.text) + elif rDevice.status_code == 401 or rDevice.status_code == 403: + token = await api_get_token(juke_id) + if token == False: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, detail="No devices connected" + ) + elif retry: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, detail="Failed to get auth" + ) + else: + return api_get_jukebox_device_check(juke_id, retry=True) + else: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, detail="No device connected" + ) + + +######GET INVOICE STUFF + + +@jukebox_ext.get("/api/v1/jukebox/jb/invoice/{juke_id}/{song_id}") +async def api_get_jukebox_invoice(juke_id, song_id): + try: + jukebox = await get_jukebox(juke_id) + print(jukebox) + except: + raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="No jukebox") + try: + + devices = await api_get_jukebox_device_check(juke_id) + deviceConnected = False + for device in devices["devices"]: + if device["id"] == jukebox.sp_device.split("-")[1]: + deviceConnected = True + if not deviceConnected: + raise HTTPException( + status_code=HTTPStatus.NOT_FOUND, detail="No device connected" + ) + except: + raise HTTPException( + status_code=HTTPStatus.NOT_FOUND, detail="No device connected" + ) + + invoice = await create_invoice( + wallet_id=jukebox.wallet, + amount=jukebox.price, + memo=jukebox.title, + extra={"tag": "jukebox"}, + ) + + payment_hash = invoice[0] + data = CreateJukeboxPayment( + invoice=invoice[1], payment_hash=payment_hash, juke_id=juke_id, song_id=song_id + ) + jukebox_payment = await create_jukebox_payment(data) + print(data) + + return data + + +@jukebox_ext.get("/api/v1/jukebox/jb/checkinvoice/{pay_hash}/{juke_id}") +async def api_get_jukebox_invoice_check( + pay_hash: str = Query(None), juke_id: str = Query(None) +): + try: + jukebox = await get_jukebox(juke_id) + except: + raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="No jukebox") + try: + status = await check_invoice_status(jukebox.wallet, pay_hash) + is_paid = not status.pending + except: + return {"paid": False} + if is_paid: + wallet = await get_wallet(jukebox.wallet) + payment = await wallet.get_payment(pay_hash) + await payment.set_pending(False) + await update_jukebox_payment(pay_hash, paid=True) + return {"paid": True} + return {"paid": False} + + +@jukebox_ext.get("/api/v1/jukebox/jb/invoicep/{song_id}/{juke_id}/{pay_hash}") +async def api_get_jukebox_invoice_paid( + song_id: str = Query(None), + juke_id: str = Query(None), + pay_hash: str = Query(None), + retry: bool = Query(False), +): + try: + jukebox = await get_jukebox(juke_id) + except: + raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="No jukebox") + await api_get_jukebox_invoice_check(pay_hash, juke_id) + jukebox_payment = await get_jukebox_payment(pay_hash) + if jukebox_payment.paid: + async with httpx.AsyncClient() as client: + r = await client.get( + "https://api.spotify.com/v1/me/player/currently-playing?market=ES", + timeout=40, + headers={"Authorization": "Bearer " + jukebox.sp_access_token}, + ) + rDevice = await client.get( + "https://api.spotify.com/v1/me/player", + timeout=40, + headers={"Authorization": "Bearer " + jukebox.sp_access_token}, + ) + isPlaying = False + if rDevice.status_code == 200: + isPlaying = rDevice.json()["is_playing"] + + if r.status_code == 204 or isPlaying == False: + async with httpx.AsyncClient() as client: + uri = ["spotify:track:" + song_id] + r = await client.put( + "https://api.spotify.com/v1/me/player/play?device_id=" + + jukebox.sp_device.split("-")[1], + json={"uris": uri}, + timeout=40, + headers={"Authorization": "Bearer " + jukebox.sp_access_token}, + ) + if r.status_code == 204: + return jukebox_payment + elif r.status_code == 401 or r.status_code == 403: + token = await api_get_token(juke_id) + if token == False: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, + detail="Invoice not paid", + ) + elif retry: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, + detail="Failed to get auth", + ) + else: + return api_get_jukebox_invoice_paid( + song_id, juke_id, pay_hash, retry=True + ) + else: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, detail="Invoice not paid" + ) + elif r.status_code == 200: + async with httpx.AsyncClient() as client: + r = await client.post( + "https://api.spotify.com/v1/me/player/queue?uri=spotify%3Atrack%3A" + + song_id + + "&device_id=" + + jukebox.sp_device.split("-")[1], + timeout=40, + headers={"Authorization": "Bearer " + jukebox.sp_access_token}, + ) + if r.status_code == 204: + return jukebox_payment + + elif r.status_code == 401 or r.status_code == 403: + token = await api_get_token(juke_id) + if token == False: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, + detail="Invoice not paid", + ) + elif retry: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, + detail="Failed to get auth", + ) + else: + return await api_get_jukebox_invoice_paid( + song_id, juke_id, pay_hash + ) + else: + raise HTTPException( + status_code=HTTPStatus.OK, detail="Invoice not paid" + ) + elif r.status_code == 401 or r.status_code == 403: + token = await api_get_token(juke_id) + if token == False: + raise HTTPException( + status_code=HTTPStatus.OK, detail="Invoice not paid" + ) + elif retry: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, detail="Failed to get auth" + ) + else: + return await api_get_jukebox_invoice_paid( + song_id, juke_id, pay_hash + ) + raise HTTPException(status_code=HTTPStatus.OK, detail="Invoice not paid") + + +############################GET TRACKS + + +@jukebox_ext.get("/api/v1/jukebox/jb/currently/{juke_id}") +async def api_get_jukebox_currently( + retry: bool = Query(False), juke_id: str = Query(None) +): + try: + jukebox = await get_jukebox(juke_id) + except: + raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="No jukebox") + async with httpx.AsyncClient() as client: + try: + r = await client.get( + "https://api.spotify.com/v1/me/player/currently-playing?market=ES", + timeout=40, + headers={"Authorization": "Bearer " + jukebox.sp_access_token}, + ) + if r.status_code == 204: + raise HTTPException(status_code=HTTPStatus.OK, detail="Nothing") + elif r.status_code == 200: + try: + response = r.json() + + track = { + "id": response["item"]["id"], + "name": response["item"]["name"], + "album": response["item"]["album"]["name"], + "artist": response["item"]["artists"][0]["name"], + "image": response["item"]["album"]["images"][0]["url"], + } + return track + except: + raise HTTPException( + status_code=HTTPStatus.NOT_FOUND, detail="Something went wrong" + ) + + elif r.status_code == 401: + token = await api_get_token(juke_id) + if token == False: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, detail="INvoice not paid" + ) + elif retry: + raise HTTPException( + status_code=HTTPStatus.FORBIDDEN, detail="Failed to get auth" + ) + else: + return await api_get_jukebox_currently(retry=True, juke_id=juke_id) + else: + raise HTTPException( + status_code=HTTPStatus.NOT_FOUND, detail="Something went wrong" + ) + except: + raise HTTPException( + status_code=HTTPStatus.NOT_FOUND, detail="Something went wrong" + ) diff --git a/lnbits/extensions/lndhub/README.md b/lnbits/extensions/lndhub/README.md new file mode 100644 index 00000000..f567d549 --- /dev/null +++ b/lnbits/extensions/lndhub/README.md @@ -0,0 +1,6 @@ +lndhub Extension
+*connect to your lnbits wallet from BlueWallet or Zeus*
+ +Lndhub has nothing to do with lnd, it is just the name of the HTTP/JSON protocol https://bluewallet.io/ uses to talk to their Lightning custodian server at https://lndhub.io/. + +Despite not having been planned to this, Lndhub because somewhat a standard for custodian wallet communication when https://t.me/lntxbot and https://zeusln.app/ implemented the same interface. And with this extension LNBits joins the same club. diff --git a/lnbits/extensions/lndhub/__init__.py b/lnbits/extensions/lndhub/__init__.py new file mode 100644 index 00000000..5980ab0d --- /dev/null +++ b/lnbits/extensions/lndhub/__init__.py @@ -0,0 +1,18 @@ +from fastapi import APIRouter + +from lnbits.db import Database +from lnbits.helpers import template_renderer + +db = Database("ext_lndhub") + +lndhub_ext: APIRouter = APIRouter(prefix="/lndhub", tags=["lndhub"]) + + +def lndhub_renderer(): + return template_renderer(["lnbits/extensions/lndhub/templates"]) + + +from .decorators import * # noqa +from .utils import * # noqa +from .views import * # noqa +from .views_api import * # noqa diff --git a/lnbits/extensions/lndhub/config.json b/lnbits/extensions/lndhub/config.json new file mode 100644 index 00000000..6285ff80 --- /dev/null +++ b/lnbits/extensions/lndhub/config.json @@ -0,0 +1,6 @@ +{ + "name": "LndHub", + "short_description": "Access lnbits from BlueWallet or Zeus", + "icon": "navigation", + "contributors": ["fiatjaf"] +} diff --git a/lnbits/extensions/lndhub/decorators.py b/lnbits/extensions/lndhub/decorators.py new file mode 100644 index 00000000..14931164 --- /dev/null +++ b/lnbits/extensions/lndhub/decorators.py @@ -0,0 +1,44 @@ +from base64 import b64decode +from fastapi.param_functions import Security + +from fastapi.security.api_key import APIKeyHeader + +from fastapi import Request, status +from starlette.exceptions import HTTPException + +from lnbits.decorators import WalletTypeInfo, get_key_type # type: ignore + + +api_key_header_auth = APIKeyHeader( + name="AUTHORIZATION", + auto_error=False, + description="Admin or Invoice key for LNDHub API's", +) + + +async def check_wallet( + r: Request, api_key_header_auth: str = Security(api_key_header_auth) +) -> WalletTypeInfo: + if not api_key_header_auth: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid auth key" + ) + + t = api_key_header_auth.split(" ")[1] + _, token = b64decode(t).decode("utf-8").split(":") + + return await get_key_type(r, api_key_header=token) + + +async def require_admin_key( + r: Request, api_key_header_auth: str = Security(api_key_header_auth) +): + wallet = await check_wallet(r, api_key_header_auth) + if wallet.wallet_type != 0: + # If wallet type is not admin then return the unauthorized status + # This also covers when the user passes an invalid key type + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, detail="Admin key required." + ) + else: + return wallet diff --git a/lnbits/extensions/lndhub/migrations.py b/lnbits/extensions/lndhub/migrations.py new file mode 100644 index 00000000..d6ea5fde --- /dev/null +++ b/lnbits/extensions/lndhub/migrations.py @@ -0,0 +1,2 @@ +async def migrate(): + pass diff --git a/lnbits/extensions/lndhub/templates/lndhub/_instructions.html b/lnbits/extensions/lndhub/templates/lndhub/_instructions.html new file mode 100644 index 00000000..4db79aba --- /dev/null +++ b/lnbits/extensions/lndhub/templates/lndhub/_instructions.html @@ -0,0 +1,35 @@ +-
+
- + Install either Zeus or + BlueWallet; + +
-
+ Go to
Add a wallet / Import walleton BlueWallet or +Settings / Add a new nodeon Zeus. +
+ - Select the desired wallet on this page; +
- Scan one of the two QR codes from the mobile wallet. +
-
+
- + Invoice URLs mean the mobile wallet will only have the + authorization to read your payments and invoices and generate new + invoices. + +
- + Admin URLs mean the mobile wallet will be able to pay + invoices.. + +
+ LndHub is a protocol invented by + BlueWallet that allows mobile + wallets to query payments and balances, generate invoices and make + payments from accounts that exist on a server. The protocol is a + collection of HTTP endpoints exposed through the internet. +
++ For a wallet that supports it, reading a QR code that contains the URL + along with secret access credentials should enable access. Currently it + is supported by Zeus and + BlueWallet. +
+
+
+
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+
+{% endblock %}
diff --git a/lnbits/extensions/lndhub/utils.py b/lnbits/extensions/lndhub/utils.py
new file mode 100644
index 00000000..3db6317a
--- /dev/null
+++ b/lnbits/extensions/lndhub/utils.py
@@ -0,0 +1,21 @@
+from binascii import unhexlify
+
+from lnbits.bolt11 import Invoice
+
+
+def to_buffer(payment_hash: str):
+ return {"type": "Buffer", "data": [b for b in unhexlify(payment_hash)]}
+
+
+def decoded_as_lndhub(invoice: Invoice):
+ return {
+ "destination": invoice.payee,
+ "payment_hash": invoice.payment_hash,
+ "num_satoshis": invoice.amount_msat / 1000,
+ "timestamp": str(invoice.date),
+ "expiry": str(invoice.expiry),
+ "description": invoice.description,
+ "fallback_addr": "",
+ "cltv_expiry": invoice.min_final_cltv_expiry,
+ "route_hints": "",
+ }
diff --git a/lnbits/extensions/lndhub/views.py b/lnbits/extensions/lndhub/views.py
new file mode 100644
index 00000000..4b015c09
--- /dev/null
+++ b/lnbits/extensions/lndhub/views.py
@@ -0,0 +1,12 @@
+from lnbits.decorators import check_user_exists
+from . import lndhub_ext, lndhub_renderer
+from fastapi import Request
+from fastapi.params import Depends
+from lnbits.core.models import User
+
+
+@lndhub_ext.get("/")
+async def lndhub_index(request: Request, user: User = Depends(check_user_exists)):
+ return lndhub_renderer().TemplateResponse(
+ "lndhub/index.html", {"request": request, "user": user.dict()}
+ )
diff --git a/lnbits/extensions/lndhub/views_api.py b/lnbits/extensions/lndhub/views_api.py
new file mode 100644
index 00000000..2df4141d
--- /dev/null
+++ b/lnbits/extensions/lndhub/views_api.py
@@ -0,0 +1,219 @@
+import time
+from base64 import urlsafe_b64encode
+from pydantic import BaseModel
+
+from lnbits.core.services import pay_invoice, create_invoice
+from lnbits.core.crud import get_payments, delete_expired_invoices
+from lnbits.decorators import WalletTypeInfo
+from lnbits.settings import WALLET
+from lnbits import bolt11
+
+from . import lndhub_ext
+from .decorators import check_wallet, require_admin_key
+from .utils import to_buffer, decoded_as_lndhub
+from http import HTTPStatus
+from starlette.exceptions import HTTPException
+from fastapi.params import Depends
+from fastapi.param_functions import Query
+
+
+@lndhub_ext.get("/ext/getinfo")
+async def lndhub_getinfo():
+ raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="bad auth")
+
+
+class AuthData(BaseModel):
+ login: str = Query(None)
+ password: str = Query(None)
+ refresh_token: str = Query(None)
+
+
+@lndhub_ext.post("/ext/auth")
+async def lndhub_auth(data: AuthData):
+ token = (
+ data.refresh_token
+ if data.refresh_token
+ else urlsafe_b64encode(
+ (data.login + ":" + data.password).encode("utf-8")
+ ).decode("ascii")
+ )
+ return {"refresh_token": token, "access_token": token}
+
+
+class AddInvoice(BaseModel):
+ amt: str = Query(None)
+ memo: str = Query(None)
+ preimage: str = Query(None)
+
+
+@lndhub_ext.post("/ext/addinvoice")
+async def lndhub_addinvoice(
+ data: AddInvoice, wallet: WalletTypeInfo = Depends(check_wallet)
+):
+ try:
+ _, pr = await create_invoice(
+ wallet_id=wallet.wallet.id,
+ amount=int(data.amt),
+ memo=data.memo,
+ extra={"tag": "lndhub"},
+ )
+ except:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Failed to create invoice"
+ )
+
+ invoice = bolt11.decode(pr)
+ return {
+ "pay_req": pr,
+ "payment_request": pr,
+ "add_index": "500",
+ "r_hash": to_buffer(invoice.payment_hash),
+ "hash": invoice.payment_hash,
+ }
+
+
+class Invoice(BaseModel):
+ invoice: str
+
+
+@lndhub_ext.post("/ext/payinvoice")
+async def lndhub_payinvoice(
+ r_invoice: Invoice, wallet: WalletTypeInfo = Depends(require_admin_key)
+):
+ try:
+ await pay_invoice(
+ wallet_id=wallet.wallet.id,
+ payment_request=r_invoice.invoice,
+ extra={"tag": "lndhub"},
+ )
+ except:
+ raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Payment failed")
+
+ invoice: bolt11.Invoice = bolt11.decode(r_invoice.invoice)
+ print("INV2", invoice)
+ return {
+ "payment_error": "",
+ "payment_preimage": "0" * 64,
+ "route": {},
+ "payment_hash": invoice.payment_hash,
+ "decoded": decoded_as_lndhub(invoice),
+ "fee_msat": 0,
+ "type": "paid_invoice",
+ "fee": 0,
+ "value": invoice.amount_msat / 1000,
+ "timestamp": int(time.time()),
+ "memo": invoice.description,
+ }
+
+
+@lndhub_ext.get("/ext/balance")
+async def lndhub_balance(wallet: WalletTypeInfo = Depends(check_wallet),):
+ return {"BTC": {"AvailableBalance": wallet.wallet.balance}}
+
+
+@lndhub_ext.get("/ext/gettxs")
+async def lndhub_gettxs(
+ wallet: WalletTypeInfo = Depends(check_wallet), limit: int = Query(0, ge=0, lt=200)
+):
+ for payment in await get_payments(
+ wallet_id=wallet.wallet.id,
+ complete=False,
+ pending=True,
+ outgoing=True,
+ incoming=False,
+ exclude_uncheckable=True,
+ ):
+ await payment.set_pending(
+ (await WALLET.get_payment_status(payment.checking_id)).pending
+ )
+ return [
+ {
+ "payment_preimage": payment.preimage,
+ "payment_hash": payment.payment_hash,
+ "fee_msat": payment.fee * 1000,
+ "type": "paid_invoice",
+ "fee": payment.fee,
+ "value": int(payment.amount / 1000),
+ "timestamp": payment.time,
+ "memo": payment.memo if not payment.pending else "Payment in transition",
+ }
+ for payment in reversed(
+ (
+ await get_payments(
+ wallet_id=wallet.wallet.id,
+ pending=True,
+ complete=True,
+ outgoing=True,
+ incoming=False,
+ )
+ )[:limit]
+ )
+ ]
+
+
+@lndhub_ext.get("/ext/getuserinvoices")
+async def lndhub_getuserinvoices(
+ wallet: WalletTypeInfo = Depends(check_wallet), limit: int = Query(0, ge=0, lt=200)
+):
+ await delete_expired_invoices()
+ for invoice in await get_payments(
+ wallet_id=wallet.wallet.id,
+ complete=False,
+ pending=True,
+ outgoing=False,
+ incoming=True,
+ exclude_uncheckable=True,
+ ):
+ await invoice.set_pending(
+ (await WALLET.get_invoice_status(invoice.checking_id)).pending
+ )
+
+ return [
+ {
+ "r_hash": to_buffer(invoice.payment_hash),
+ "payment_request": invoice.bolt11,
+ "add_index": "500",
+ "description": invoice.memo,
+ "payment_hash": invoice.payment_hash,
+ "ispaid": not invoice.pending,
+ "amt": int(invoice.amount / 1000),
+ "expire_time": int(time.time() + 1800),
+ "timestamp": invoice.time,
+ "type": "user_invoice",
+ }
+ for invoice in reversed(
+ (
+ await get_payments(
+ wallet_id=wallet.wallet.id,
+ pending=True,
+ complete=True,
+ incoming=True,
+ outgoing=False,
+ )
+ )[:limit]
+ )
+ ]
+
+
+@lndhub_ext.get("/ext/getbtc")
+async def lndhub_getbtc(wallet: WalletTypeInfo = Depends(check_wallet)):
+ "load an address for incoming onchain btc"
+ return []
+
+
+@lndhub_ext.get("/ext/getpending")
+async def lndhub_getpending(wallet: WalletTypeInfo = Depends(check_wallet)):
+ "pending onchain transactions"
+ return []
+
+
+@lndhub_ext.get("/ext/decodeinvoice")
+async def lndhub_decodeinvoice(invoice: str = Query(None)):
+ inv = bolt11.decode(invoice)
+ return decoded_as_lndhub(inv)
+
+
+@lndhub_ext.get("/ext/checkrouteinvoice")
+async def lndhub_checkrouteinvoice():
+ "not implemented on canonical lndhub"
+ pass
diff --git a/lnbits/extensions/lnticket/__init__.py b/lnbits/extensions/lnticket/__init__.py
index 9394a1c9..c1f382eb 100644
--- a/lnbits/extensions/lnticket/__init__.py
+++ b/lnbits/extensions/lnticket/__init__.py
@@ -14,12 +14,9 @@ lnticket_ext: APIRouter = APIRouter(
# "lnticket", __name__, static_folder="static", template_folder="templates"
)
+
def lnticket_renderer():
- return template_renderer(
- [
- "lnbits/extensions/lnticket/templates",
- ]
- )
+ return template_renderer(["lnbits/extensions/lnticket/templates"])
from .views_api import * # noqa
@@ -30,4 +27,3 @@ from .tasks import wait_for_paid_invoices
def lnticket_start():
loop = asyncio.get_event_loop()
loop.create_task(catch_everything_and_restart(wait_for_paid_invoices))
-
diff --git a/lnbits/extensions/lnticket/crud.py b/lnbits/extensions/lnticket/crud.py
index e391abb5..8fe17090 100644
--- a/lnbits/extensions/lnticket/crud.py
+++ b/lnbits/extensions/lnticket/crud.py
@@ -9,16 +9,23 @@ import httpx
async def create_ticket(
- payment_hash: str,
- wallet: str,
- data: CreateTicketData
+ payment_hash: str, wallet: str, data: CreateTicketData
) -> Tickets:
await db.execute(
"""
INSERT INTO lnticket.ticket (id, form, email, ltext, name, wallet, sats, paid)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
""",
- (payment_hash, data.form, data.email, data.ltext, data.name, wallet, data.sats, False),
+ (
+ payment_hash,
+ data.form,
+ data.email,
+ data.ltext,
+ data.name,
+ wallet,
+ data.sats,
+ False,
+ ),
)
ticket = await get_ticket(payment_hash)
@@ -99,17 +106,23 @@ async def delete_ticket(ticket_id: str) -> None:
# FORMS
-async def create_form(
- data: CreateFormData,
- wallet: Wallet,
-) -> Forms:
+async def create_form(data: CreateFormData, wallet: Wallet) -> Forms:
form_id = urlsafe_short_hash()
await db.execute(
"""
INSERT INTO lnticket.form2 (id, wallet, name, webhook, description, flatrate, amount, amountmade)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
""",
- (form_id, wallet.id, wallet.name, data.webhook, data.description, data.flatrate, data.amount, 0),
+ (
+ form_id,
+ wallet.id,
+ wallet.name,
+ data.webhook,
+ data.description,
+ data.flatrate,
+ data.amount,
+ 0,
+ ),
)
form = await get_form(form_id)
diff --git a/lnbits/extensions/lnticket/migrations.py b/lnbits/extensions/lnticket/migrations.py
index abcd5c7f..37fbdc86 100644
--- a/lnbits/extensions/lnticket/migrations.py
+++ b/lnbits/extensions/lnticket/migrations.py
@@ -79,16 +79,7 @@ async def m002_changed(db):
)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
""",
- (
- row[0],
- row[1],
- row[2],
- row[3],
- row[4],
- row[5],
- row[6],
- True,
- ),
+ (row[0], row[1], row[2], row[3], row[4], row[5], row[6], True),
)
await db.execute("DROP TABLE lnticket.tickets")
@@ -134,15 +125,7 @@ async def m003_changed(db):
)
VALUES (?, ?, ?, ?, ?, ?, ?)
""",
- (
- row[0],
- row[1],
- row[2],
- row[3],
- row[4],
- row[5],
- row[6],
- ),
+ (row[0], row[1], row[2], row[3], row[4], row[5], row[6]),
)
await db.execute("DROP TABLE lnticket.forms")
@@ -189,14 +172,6 @@ async def m004_changed(db):
)
VALUES (?, ?, ?, ?, ?, ?, ?)
""",
- (
- row[0],
- row[1],
- row[2],
- row[3],
- row[4],
- row[5],
- row[6],
- ),
+ (row[0], row[1], row[2], row[3], row[4], row[5], row[6]),
)
await db.execute("DROP TABLE lnticket.form")
diff --git a/lnbits/extensions/lnticket/models.py b/lnbits/extensions/lnticket/models.py
index 6fac90c2..50ffc1e1 100644
--- a/lnbits/extensions/lnticket/models.py
+++ b/lnbits/extensions/lnticket/models.py
@@ -2,6 +2,7 @@ from typing import Optional
from fastapi.param_functions import Query
from pydantic import BaseModel
+
class CreateFormData(BaseModel):
name: str = Query(...)
webhook: str = Query(None)
@@ -9,6 +10,7 @@ class CreateFormData(BaseModel):
amount: int = Query(..., ge=0)
flatrate: int = Query(...)
+
class CreateTicketData(BaseModel):
form: str = Query(...)
name: str = Query(...)
@@ -16,6 +18,7 @@ class CreateTicketData(BaseModel):
ltext: str = Query(...)
sats: int = Query(..., ge=0)
+
class Forms(BaseModel):
id: str
wallet: str
diff --git a/lnbits/extensions/lnticket/views.py b/lnbits/extensions/lnticket/views.py
index f7f50e37..85be27b5 100644
--- a/lnbits/extensions/lnticket/views.py
+++ b/lnbits/extensions/lnticket/views.py
@@ -14,13 +14,16 @@ from fastapi.templating import Jinja2Templates
templates = Jinja2Templates(directory="templates")
+
@lnticket_ext.get("/", response_class=HTMLResponse)
# not needed as we automatically get the user with the given ID
# If no user with this ID is found, an error is raised
# @validate_uuids(["usr"], required=True)
# @check_user_exists()
async def index(request: Request, user: User = Depends(check_user_exists)):
- return lnticket_renderer().TemplateResponse("lnticket/index.html", {"request": request,"user": user.dict()})
+ return lnticket_renderer().TemplateResponse(
+ "lnticket/index.html", {"request": request, "user": user.dict()}
+ )
@lnticket_ext.get("/{form_id}")
@@ -28,8 +31,7 @@ async def display(request: Request, form_id):
form = await get_form(form_id)
if not form:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail="LNTicket does not exist."
+ status_code=HTTPStatus.NOT_FOUND, detail="LNTicket does not exist."
)
# abort(HTTPStatus.NOT_FOUND, "LNTicket does not exist.")
@@ -37,11 +39,13 @@ async def display(request: Request, form_id):
return lnticket_renderer().TemplateResponse(
"lnticket/display.html",
- {"request": request,
- "form_id":form.id,
- "form_name":form.name,
- "form_desc":form.description,
- "form_amount":form.amount,
- "form_flatrate":form.flatrate,
- "form_wallet":wallet.inkey}
+ {
+ "request": request,
+ "form_id": form.id,
+ "form_name": form.name,
+ "form_desc": form.description,
+ "form_amount": form.amount,
+ "form_flatrate": form.flatrate,
+ "form_wallet": wallet.inkey,
+ },
)
diff --git a/lnbits/extensions/lnticket/views_api.py b/lnbits/extensions/lnticket/views_api.py
index 1474518b..e78a4c71 100644
--- a/lnbits/extensions/lnticket/views_api.py
+++ b/lnbits/extensions/lnticket/views_api.py
@@ -34,7 +34,11 @@ from .crud import (
@lnticket_ext.get("/api/v1/forms")
-async def api_forms_get(r: Request, all_wallets: bool = Query(False), wallet: WalletTypeInfo = Depends(get_key_type)):
+async def api_forms_get(
+ r: Request,
+ all_wallets: bool = Query(False),
+ wallet: WalletTypeInfo = Depends(get_key_type),
+):
wallet_ids = [wallet.wallet.id]
if all_wallets:
@@ -42,6 +46,7 @@ async def api_forms_get(r: Request, all_wallets: bool = Query(False), wallet: Wa
return [form.dict() for form in await get_forms(wallet_ids)]
+
@lnticket_ext.post("/api/v1/forms", status_code=HTTPStatus.CREATED)
@lnticket_ext.put("/api/v1/forms/{form_id}")
# @api_check_wallet_key("invoice")
@@ -55,21 +60,21 @@ async def api_forms_get(r: Request, all_wallets: bool = Query(False), wallet: Wa
# "flatrate": {"type": "integer", "required": True},
# }
# )
-async def api_form_create(data: CreateFormData, form_id=None, wallet: WalletTypeInfo = Depends(get_key_type)):
+async def api_form_create(
+ data: CreateFormData, form_id=None, wallet: WalletTypeInfo = Depends(get_key_type)
+):
if form_id:
form = await get_form(form_id)
if not form:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail=f"Form does not exist."
+ status_code=HTTPStatus.NOT_FOUND, detail=f"Form does not exist."
)
# return {"message": "Form does not exist."}, HTTPStatus.NOT_FOUND
if form.wallet != wallet.wallet.id:
raise HTTPException(
- status_code=HTTPStatus.FORBIDDEN,
- detail=f"Not your form."
+ status_code=HTTPStatus.FORBIDDEN, detail=f"Not your form."
)
# return {"message": "Not your form."}, HTTPStatus.FORBIDDEN
@@ -86,16 +91,12 @@ async def api_form_delete(form_id, wallet: WalletTypeInfo = Depends(get_key_type
if not form:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail=f"Form does not exist."
+ status_code=HTTPStatus.NOT_FOUND, detail=f"Form does not exist."
)
# return {"message": "Form does not exist."}, HTTPStatus.NOT_FOUND
if form.wallet != wallet.wallet.id:
- raise HTTPException(
- status_code=HTTPStatus.FORBIDDEN,
- detail=f"Not your form."
- )
+ raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail=f"Not your form.")
# return {"message": "Not your form."}, HTTPStatus.FORBIDDEN
await delete_form(form_id)
@@ -109,7 +110,9 @@ async def api_form_delete(form_id, wallet: WalletTypeInfo = Depends(get_key_type
@lnticket_ext.get("/api/v1/tickets")
# @api_check_wallet_key("invoice")
-async def api_tickets(all_wallets: bool = Query(False), wallet: WalletTypeInfo = Depends(get_key_type)):
+async def api_tickets(
+ all_wallets: bool = Query(False), wallet: WalletTypeInfo = Depends(get_key_type)
+):
wallet_ids = [wallet.wallet.id]
if all_wallets:
@@ -117,6 +120,7 @@ async def api_tickets(all_wallets: bool = Query(False), wallet: WalletTypeInfo =
return [form.dict() for form in await get_tickets(wallet_ids)]
+
@lnticket_ext.post("/api/v1/tickets/{form_id}", status_code=HTTPStatus.CREATED)
# @api_validate_post_request(
# schema={
@@ -131,8 +135,7 @@ async def api_ticket_make_ticket(data: CreateTicketData, form_id):
form = await get_form(form_id)
if not form:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail=f"LNTicket does not exist."
+ status_code=HTTPStatus.NOT_FOUND, detail=f"LNTicket does not exist."
)
# return {"message": "LNTicket does not exist."}, HTTPStatus.NOT_FOUND
@@ -146,10 +149,7 @@ async def api_ticket_make_ticket(data: CreateTicketData, form_id):
extra={"tag": "lnticket"},
)
except Exception as e:
- raise HTTPException(
- status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
- detail=str(e)
- )
+ raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(e))
# return {"message": str(e)}, HTTPStatus.INTERNAL_SERVER_ERROR
ticket = await create_ticket(
@@ -158,18 +158,14 @@ async def api_ticket_make_ticket(data: CreateTicketData, form_id):
if not ticket:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail="LNTicket could not be fetched."
+ status_code=HTTPStatus.NOT_FOUND, detail="LNTicket could not be fetched."
)
# return (
# {"message": "LNTicket could not be fetched."},
# HTTPStatus.NOT_FOUND,
# )
- return {
- "payment_hash": payment_hash,
- "payment_request": payment_request
- }
+ return {"payment_hash": payment_hash, "payment_request": payment_request}
@lnticket_ext.get("/api/v1/tickets/{payment_hash}", status_code=HTTPStatus.OK)
@@ -198,16 +194,12 @@ async def api_ticket_delete(ticket_id, wallet: WalletTypeInfo = Depends(get_key_
if not ticket:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail=f"LNTicket does not exist."
+ status_code=HTTPStatus.NOT_FOUND, detail=f"LNTicket does not exist."
)
# return {"message": "Paywall does not exist."}, HTTPStatus.NOT_FOUND
if ticket.wallet != wallet.wallet.id:
- raise HTTPException(
- status_code=HTTPStatus.FORBIDDEN,
- detail="Not your ticket."
- )
+ raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="Not your ticket.")
# return {"message": "Not your ticket."}, HTTPStatus.FORBIDDEN
await delete_ticket(ticket_id)
diff --git a/lnbits/extensions/lnurlp/__init__.py b/lnbits/extensions/lnurlp/__init__.py
index af12d57f..ea8e509a 100644
--- a/lnbits/extensions/lnurlp/__init__.py
+++ b/lnbits/extensions/lnurlp/__init__.py
@@ -24,12 +24,9 @@ lnurlp_ext: APIRouter = APIRouter(
# "lnurlp", __name__, static_folder="static", template_folder="templates"
)
+
def lnurlp_renderer():
- return template_renderer(
- [
- "lnbits/extensions/lnurlp/templates",
- ]
- )
+ return template_renderer(["lnbits/extensions/lnurlp/templates"])
from .views_api import * # noqa
@@ -37,13 +34,12 @@ from .views import * # noqa
from .tasks import wait_for_paid_invoices
from .lnurl import * # noqa
+
def lnurlp_start():
loop = asyncio.get_event_loop()
loop.create_task(catch_everything_and_restart(wait_for_paid_invoices))
-
-
# from lnbits.tasks import record_async
# lnurlp_ext.record(record_async(register_listeners))
diff --git a/lnbits/extensions/lnurlp/crud.py b/lnbits/extensions/lnurlp/crud.py
index 892d9e98..4215faf6 100644
--- a/lnbits/extensions/lnurlp/crud.py
+++ b/lnbits/extensions/lnurlp/crud.py
@@ -5,10 +5,7 @@ from . import db
from .models import PayLink, CreatePayLinkData
-async def create_pay_link(
- data: CreatePayLinkData,
- wallet_id: str
-) -> PayLink:
+async def create_pay_link(data: CreatePayLinkData, wallet_id: str) -> PayLink:
returning = "" if db.type == SQLITE else "RETURNING ID"
method = db.execute if db.type == SQLITE else db.fetchone
diff --git a/lnbits/extensions/lnurlp/lnurl.py b/lnbits/extensions/lnurlp/lnurl.py
index ca17646f..f7a615a4 100644
--- a/lnbits/extensions/lnurlp/lnurl.py
+++ b/lnbits/extensions/lnurlp/lnurl.py
@@ -2,7 +2,12 @@ import hashlib
import math
from http import HTTPStatus
from fastapi import FastAPI, Request
-from lnurl import LnurlPayResponse, LnurlPayActionResponse, LnurlErrorResponse # type: ignore
+from starlette.exceptions import HTTPException
+from lnurl import (
+ LnurlPayResponse,
+ LnurlPayActionResponse,
+ LnurlErrorResponse,
+) # type: ignore
from lnbits.core.services import create_invoice
from lnbits.utils.exchange_rates import get_fiat_rate_satoshis
@@ -11,13 +16,16 @@ from . import lnurlp_ext
from .crud import increment_pay_link
-@lnurlp_ext.get("/api/v1/lnurl/{link_id}", status_code=HTTPStatus.OK, name="lnurlp.api_lnurl_response")
+@lnurlp_ext.get(
+ "/api/v1/lnurl/{link_id}",
+ status_code=HTTPStatus.OK,
+ name="lnurlp.api_lnurl_response",
+)
async def api_lnurl_response(request: Request, link_id):
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."
+ status_code=HTTPStatus.NOT_FOUND, detail="Pay link does not exist."
)
rate = await get_fiat_rate_satoshis(link.currency) if link.currency else 1
@@ -36,13 +44,16 @@ async def api_lnurl_response(request: Request, link_id):
return params
-@lnurlp_ext.get("/api/v1/lnurl/cb/{link_id}", status_code=HTTPStatus.OK, name="lnurlp.api_lnurl_callback")
+@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):
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."
+ 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
@@ -54,23 +65,22 @@ async def api_lnurl_callback(request: Request, link_id):
min = link.min * 1000
max = link.max * 1000
- amount_received = int(request.query_params.get('amount') or 0)
+ amount_received = int(request.query_params.get("amount") or 0)
if amount_received < min:
return LnurlErrorResponse(
- reason=f"Amount {amount_received} is smaller than minimum {min}."
- ).dict()
+ reason=f"Amount {amount_received} is smaller than minimum {min}."
+ ).dict()
elif amount_received > max:
return LnurlErrorResponse(
- reason=f"Amount {amount_received} is greater than maximum {max}."
- ).dict()
-
+ reason=f"Amount {amount_received} 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()
+ reason=f"Got a comment with {len(comment)} characters, but can only accept {link.comment_chars}"
+ ).dict()
payment_hash, payment_request = await create_invoice(
wallet_id=link.wallet,
@@ -79,20 +89,20 @@ async def api_lnurl_callback(request: Request, link_id):
description_hash=hashlib.sha256(
link.lnurlpay_metadata.encode("utf-8")
).digest(),
- extra={"tag": "lnurlp", "link": link.id, "comment": comment, 'extra': request.query_params.get('amount')},
+ extra={
+ "tag": "lnurlp",
+ "link": link.id,
+ "comment": comment,
+ "extra": request.query_params.get("amount"),
+ },
)
success_action = link.success_action(payment_hash)
if success_action:
resp = LnurlPayActionResponse(
- pr=payment_request,
- success_action=success_action,
- routes=[],
+ pr=payment_request, success_action=success_action, routes=[]
)
else:
- resp = LnurlPayActionResponse(
- pr=payment_request,
- routes=[],
- )
+ resp = LnurlPayActionResponse(pr=payment_request, routes=[])
return resp.dict()
diff --git a/lnbits/extensions/lnurlp/models.py b/lnbits/extensions/lnurlp/models.py
index 4dfef94a..6fc9cc1a 100644
--- a/lnbits/extensions/lnurlp/models.py
+++ b/lnbits/extensions/lnurlp/models.py
@@ -8,15 +8,17 @@ from lnurl.types import LnurlPayMetadata # type: ignore
from sqlite3 import Row
from pydantic import BaseModel
+
class CreatePayLinkData(BaseModel):
- description: str
- min: int = Query(0.01, ge=0.01)
- max: int = Query(0.01, ge=0.01)
- currency: str = Query(None)
- comment_chars: int = Query(0, ge=0, lt=800)
- webhook_url: str = Query(None)
- success_text: str = Query(None)
- success_url: str = Query(None)
+ description: str
+ min: int = Query(0.01, ge=0.01)
+ max: int = Query(0.01, ge=0.01)
+ currency: str = Query(None)
+ comment_chars: int = Query(0, ge=0, lt=800)
+ webhook_url: str = Query(None)
+ success_text: str = Query(None)
+ success_url: str = Query(None)
+
class PayLink(BaseModel):
id: int
@@ -37,7 +39,6 @@ class PayLink(BaseModel):
data = dict(row)
return cls(**data)
-
def lnurl(self, req: Request) -> str:
url = req.url_for("lnurlp.api_lnurl_response", link_id=self.id)
return lnurl_encode(url)
@@ -58,9 +59,6 @@ class PayLink(BaseModel):
"url": urlunparse(url),
}
elif self.success_text:
- return {
- "tag": "message",
- "message": self.success_text,
- }
+ return {"tag": "message", "message": self.success_text}
else:
return None
diff --git a/lnbits/extensions/lnurlp/tasks.py b/lnbits/extensions/lnurlp/tasks.py
index 470fdea9..b632fa13 100644
--- a/lnbits/extensions/lnurlp/tasks.py
+++ b/lnbits/extensions/lnurlp/tasks.py
@@ -17,6 +17,7 @@ async def wait_for_paid_invoices():
payment = await invoice_queue.get()
await on_invoice_paid(payment)
+
async def on_invoice_paid(payment: Payment) -> None:
if "lnurlp" != payment.extra.get("tag"):
# not an lnurlp invoice
diff --git a/lnbits/extensions/lnurlp/views.py b/lnbits/extensions/lnurlp/views.py
index 74cbd87b..d39a5ebf 100644
--- a/lnbits/extensions/lnurlp/views.py
+++ b/lnbits/extensions/lnurlp/views.py
@@ -14,34 +14,35 @@ from lnbits.core.models import User
templates = Jinja2Templates(directory="templates")
+
@lnurlp_ext.get("/", response_class=HTMLResponse)
# @validate_uuids(["usr"], required=True)
# @check_user_exists()
async def index(request: Request, user: User = Depends(check_user_exists)):
- return lnurlp_renderer().TemplateResponse("lnurlp/index.html", {"request": request, "user": user.dict()})
+ return lnurlp_renderer().TemplateResponse(
+ "lnurlp/index.html", {"request": request, "user": user.dict()}
+ )
@lnurlp_ext.get("/{link_id}", response_class=HTMLResponse)
-async def display(request: Request,link_id):
+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."
+ status_code=HTTPStatus.NOT_FOUND, detail="Pay link does not exist."
)
# abort(HTTPStatus.NOT_FOUND, "Pay link does not exist.")
- ctx = {"request": request, "lnurl":link.lnurl(req=request)}
+ 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):
+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."
+ status_code=HTTPStatus.NOT_FOUND, detail="Pay link does not exist."
)
# abort(HTTPStatus.NOT_FOUND, "Pay link does not exist.")
- ctx = {"request": request, "lnurl":link.lnurl(req=request)}
+ ctx = {"request": request, "lnurl": link.lnurl(req=request)}
return lnurlp_renderer().TemplateResponse("lnurlp/print_qr.html", ctx)
diff --git a/lnbits/extensions/lnurlp/views_api.py b/lnbits/extensions/lnurlp/views_api.py
index f895f05b..7558006f 100644
--- a/lnbits/extensions/lnurlp/views_api.py
+++ b/lnbits/extensions/lnurlp/views_api.py
@@ -23,6 +23,7 @@ from .crud import (
delete_pay_link,
)
+
@lnurlp_ext.get("/api/v1/currencies")
async def api_list_currencies_available():
return list(currencies.keys())
@@ -30,14 +31,21 @@ async def api_list_currencies_available():
@lnurlp_ext.get("/api/v1/links", status_code=HTTPStatus.OK)
# @api_check_wallet_key("invoice")
-async def api_links(req: Request, wallet: WalletTypeInfo = Depends(get_key_type), all_wallets: bool = Query(False)):
+async def api_links(
+ req: Request,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ all_wallets: bool = Query(False),
+):
wallet_ids = [wallet.wallet.id]
if all_wallets:
wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids
try:
- return [{**link.dict(), "lnurl": link.lnurl(req)} for link in await get_pay_links(wallet_ids)]
+ return [
+ {**link.dict(), "lnurl": link.lnurl(req)}
+ for link in await get_pay_links(wallet_ids)
+ ]
# return [
# {**link.dict(), "lnurl": link.lnurl}
# for link in await get_pay_links(wallet_ids)
@@ -58,20 +66,20 @@ async def api_links(req: Request, wallet: WalletTypeInfo = Depends(get_key_type)
@lnurlp_ext.get("/api/v1/links/{link_id}", status_code=HTTPStatus.OK)
# @api_check_wallet_key("invoice")
-async def api_link_retrieve(r: Request, link_id, wallet: WalletTypeInfo = Depends(get_key_type)):
+async def api_link_retrieve(
+ r: Request, link_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
link = await get_pay_link(link_id)
if not link:
raise HTTPException(
- detail="Pay link does not exist.",
- status_code=HTTPStatus.NOT_FOUND
+ detail="Pay link does not exist.", status_code=HTTPStatus.NOT_FOUND
)
# return {"message": "Pay link does not exist."}, HTTPStatus.NOT_FOUND
if link.wallet != wallet.wallet.id:
raise HTTPException(
- detail="Not your pay link.",
- status_code=HTTPStatus.FORBIDDEN
+ detail="Not your pay link.", status_code=HTTPStatus.FORBIDDEN
)
# return {"message": "Not your pay link."}, HTTPStatus.FORBIDDEN
@@ -81,11 +89,14 @@ async def api_link_retrieve(r: Request, link_id, wallet: WalletTypeInfo = Depend
@lnurlp_ext.post("/api/v1/links", status_code=HTTPStatus.CREATED)
@lnurlp_ext.put("/api/v1/links/{link_id}", status_code=HTTPStatus.OK)
# @api_check_wallet_key("invoice")
-async def api_link_create_or_update(data: CreatePayLinkData, link_id=None, wallet: WalletTypeInfo = Depends(get_key_type)):
+async def api_link_create_or_update(
+ data: CreatePayLinkData,
+ link_id=None,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+):
if data.min > data.max:
raise HTTPException(
- detail="Min is greater than max.",
- status_code=HTTPStatus.BAD_REQUEST
+ detail="Min is greater than max.", status_code=HTTPStatus.BAD_REQUEST
)
# return {"message": "Min is greater than max."}, HTTPStatus.BAD_REQUEST
@@ -93,15 +104,14 @@ async def api_link_create_or_update(data: CreatePayLinkData, link_id=None, walle
round(data.min) != data.min or round(data.max) != data.max
):
raise HTTPException(
- detail="Must use full satoshis.",
- status_code=HTTPStatus.BAD_REQUEST
+ detail="Must use full satoshis.", status_code=HTTPStatus.BAD_REQUEST
)
# return {"message": "Must use full satoshis."}, HTTPStatus.BAD_REQUEST
if "success_url" in data and data.success_url[:8] != "https://":
raise HTTPException(
detail="Success URL must be secure https://...",
- status_code=HTTPStatus.BAD_REQUEST
+ status_code=HTTPStatus.BAD_REQUEST,
)
# return (
# {"message": "Success URL must be secure https://..."},
@@ -113,8 +123,7 @@ async def api_link_create_or_update(data: CreatePayLinkData, link_id=None, walle
if not link:
raise HTTPException(
- detail="Pay link does not exist.",
- status_code=HTTPStatus.NOT_FOUND
+ detail="Pay link does not exist.", status_code=HTTPStatus.NOT_FOUND
)
# return (
# {"message": "Pay link does not exist."},
@@ -123,12 +132,11 @@ async def api_link_create_or_update(data: CreatePayLinkData, link_id=None, walle
if link.wallet != wallet.wallet.id:
raise HTTPException(
- detail="Not your pay link.",
- status_code=HTTPStatus.FORBIDDEN
+ detail="Not your pay link.", status_code=HTTPStatus.FORBIDDEN
)
# return {"message": "Not your pay link."}, HTTPStatus.FORBIDDEN
- link = await update_pay_link(link_id, data)
+ link = await update_pay_link(data, link_id=link_id)
else:
link = await create_pay_link(data, wallet_id=wallet.wallet.id)
print("LINK", link)
@@ -142,15 +150,13 @@ async def api_link_delete(link_id, wallet: WalletTypeInfo = Depends(get_key_type
if not link:
raise HTTPException(
- detail="Pay link does not exist.",
- status_code=HTTPStatus.NOT_FOUND
+ detail="Pay link does not exist.", status_code=HTTPStatus.NOT_FOUND
)
# return {"message": "Pay link does not exist."}, HTTPStatus.NOT_FOUND
if link.wallet != wallet.wallet.id:
raise HTTPException(
- detail="Not your pay link.",
- status_code=HTTPStatus.FORBIDDEN
+ detail="Not your pay link.", status_code=HTTPStatus.FORBIDDEN
)
# return {"message": "Not your pay link."}, HTTPStatus.FORBIDDEN
diff --git a/lnbits/extensions/lnurlpos/README.md b/lnbits/extensions/lnurlpos/README.md
new file mode 100644
index 00000000..e7713055
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/README.md
@@ -0,0 +1,3 @@
+# LNURLPoS
+
+For offline LNURL PoS devices
diff --git a/lnbits/extensions/lnurlpos/__init__.py b/lnbits/extensions/lnurlpos/__init__.py
new file mode 100644
index 00000000..4c86c827
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/__init__.py
@@ -0,0 +1,20 @@
+import asyncio
+from fastapi import APIRouter, FastAPI
+from fastapi.staticfiles import StaticFiles
+from starlette.routing import Mount
+from lnbits.db import Database
+from lnbits.helpers import template_renderer
+from lnbits.tasks import catch_everything_and_restart
+
+db = Database("ext_lnurlpos")
+
+lnurlpos_ext: APIRouter = APIRouter(prefix="/lnurlpos", tags=["lnurlpos"])
+
+
+def lnurlpos_renderer():
+ return template_renderer(["lnbits/extensions/lnurlpos/templates"])
+
+
+from .views_api import * # noqa
+from .views import * # noqa
+from .lnurl import * # noqa
diff --git a/lnbits/extensions/lnurlpos/config.json b/lnbits/extensions/lnurlpos/config.json
new file mode 100644
index 00000000..2688e5a5
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/config.json
@@ -0,0 +1,6 @@
+{
+ "name": "LNURLPoS",
+ "short_description": "For offline LNURL PoS systems",
+ "icon": "point_of_sale",
+ "contributors": ["arcbtc"]
+}
diff --git a/lnbits/extensions/lnurlpos/crud.py b/lnbits/extensions/lnurlpos/crud.py
new file mode 100644
index 00000000..5a85fa33
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/crud.py
@@ -0,0 +1,113 @@
+from datetime import datetime
+from typing import List, Optional, Union
+from lnbits.helpers import urlsafe_short_hash
+from typing import List, Optional
+from . import db
+from .models import lnurlposs, lnurlpospayment, createLnurlpos
+
+###############lnurlposS##########################
+
+
+async def create_lnurlpos(
+ data: createLnurlpos,
+) -> lnurlposs:
+ print(data)
+ lnurlpos_id = urlsafe_short_hash()
+ lnurlpos_key = urlsafe_short_hash()
+ await db.execute(
+ """
+ INSERT INTO lnurlpos.lnurlposs (
+ id,
+ key,
+ title,
+ wallet,
+ currency
+ )
+ VALUES (?, ?, ?, ?, ?)
+ """,
+ (lnurlpos_id, lnurlpos_key, data.title, data.wallet, data.currency),
+ )
+ return await get_lnurlpos(lnurlpos_id)
+
+
+async def update_lnurlpos(lnurlpos_id: str, **kwargs) -> Optional[lnurlposs]:
+ q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
+ await db.execute(
+ f"UPDATE lnurlpos.lnurlposs SET {q} WHERE id = ?",
+ (*kwargs.values(), lnurlpos_id),
+ )
+ row = await db.fetchone(
+ "SELECT * FROM lnurlpos.lnurlposs WHERE id = ?", (lnurlpos_id,)
+ )
+ return lnurlposs.from_row(row) if row else None
+
+
+async def get_lnurlpos(lnurlpos_id: str) -> lnurlposs:
+ row = await db.fetchone(
+ "SELECT * FROM lnurlpos.lnurlposs WHERE id = ?", (lnurlpos_id,)
+ )
+ return lnurlposs.from_row(row) if row else None
+
+
+async def get_lnurlposs(wallet_ids: Union[str, List[str]]) -> List[lnurlposs]:
+ wallet_ids = [wallet_ids]
+ q = ",".join(["?"] * len(wallet_ids[0]))
+ rows = await db.fetchall(
+ f"""
+ SELECT * FROM lnurlpos.lnurlposs WHERE wallet IN ({q})
+ ORDER BY id
+ """,
+ (*wallet_ids,),
+ )
+
+ return [lnurlposs.from_row(row) for row in rows]
+
+
+async def delete_lnurlpos(lnurlpos_id: str) -> None:
+ await db.execute("DELETE FROM lnurlpos.lnurlposs WHERE id = ?", (lnurlpos_id,))
+
+ ########################lnulpos payments###########################
+
+
+async def create_lnurlpospayment(
+ posid: str,
+ payload: Optional[str] = None,
+ pin: Optional[str] = None,
+ sats: Optional[int] = 0,
+) -> lnurlpospayment:
+ lnurlpospayment_id = urlsafe_short_hash()
+ await db.execute(
+ """
+ INSERT INTO lnurlpos.lnurlpospayment (
+ id,
+ posid,
+ payload,
+ pin,
+ sats
+ )
+ VALUES (?, ?, ?, ?, ?)
+ """,
+ (lnurlpospayment_id, posid, payload, pin, sats),
+ )
+ return await get_lnurlpospayment(lnurlpospayment_id)
+
+
+async def update_lnurlpospayment(
+ lnurlpospayment_id: str, **kwargs
+) -> Optional[lnurlpospayment]:
+ q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
+ await db.execute(
+ f"UPDATE lnurlpos.lnurlpospayment SET {q} WHERE id = ?",
+ (*kwargs.values(), lnurlpospayment_id),
+ )
+ row = await db.fetchone(
+ "SELECT * FROM lnurlpos.lnurlpospayment WHERE id = ?", (lnurlpospayment_id,)
+ )
+ return lnurlpospayment.from_row(row) if row else None
+
+
+async def get_lnurlpospayment(lnurlpospayment_id: str) -> lnurlpospayment:
+ row = await db.fetchone(
+ "SELECT * FROM lnurlpos.lnurlpospayment WHERE id = ?", (lnurlpospayment_id,)
+ )
+ return lnurlpospayment.from_row(row) if row else None
diff --git a/lnbits/extensions/lnurlpos/lnurl.py b/lnbits/extensions/lnurlpos/lnurl.py
new file mode 100644
index 00000000..2cfbc4ba
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/lnurl.py
@@ -0,0 +1,108 @@
+import json
+import hashlib
+import math
+from lnurl import LnurlPayResponse, LnurlPayActionResponse, LnurlErrorResponse # type: ignore
+from lnurl.types import LnurlPayMetadata
+from lnbits.core.services import create_invoice
+from hashlib import md5
+from fastapi import Request
+from fastapi.param_functions import Query
+from . import lnurlpos_ext
+from fastapi.templating import Jinja2Templates
+from starlette.exceptions import HTTPException
+from starlette.responses import HTMLResponse
+from http import HTTPStatus
+from fastapi.params import Depends
+from fastapi.param_functions import Query
+from .crud import (
+ get_lnurlpos,
+ create_lnurlpospayment,
+ get_lnurlpospayment,
+ update_lnurlpospayment,
+)
+from lnbits.utils.exchange_rates import fiat_amount_as_satoshis
+
+
+@lnurlpos_ext.get("/api/v1/lnurl/{nonce}/{payload}/{pos_id}")
+async def lnurl_response(
+ request: Request,
+ nonce: str = Query(None),
+ pos_id: str = Query(None),
+ payload: str = Query(None),
+):
+ pos = await get_lnurlpos(pos_id)
+ if not pos:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="lnurlpos not found."
+ )
+ nonce1 = bytes.fromhex(nonce)
+ payload1 = bytes.fromhex(payload)
+ h = hashlib.sha256(nonce1)
+ h.update(pos.key.encode())
+ s = h.digest()
+ res = bytearray(payload1)
+ for i in range(len(res)):
+ res[i] = res[i] ^ s[i]
+ decryptedAmount = float(int.from_bytes(res[2:6], "little") / 100)
+ decryptedPin = int.from_bytes(res[:2], "little")
+ if type(decryptedAmount) != float:
+
+ raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="Not an amount.")
+ price_msat = (
+ await fiat_amount_as_satoshis(decryptedAmount, pos.currency)
+ if pos.currency != "sat"
+ else pos.currency
+ ) * 1000
+
+ lnurlpospayment = await create_lnurlpospayment(
+ posid=pos.id, payload=payload, sats=price_msat, pin=decryptedPin
+ )
+ if not lnurlpospayment:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN, detail="Could not create payment"
+ )
+
+ payResponse = {
+ "tag": "payRequest",
+ "callback": request.url_for(
+ "lnurlpos.lnurl_callback",
+ paymentid=lnurlpospayment.id,
+ ),
+ "metadata": LnurlPayMetadata(json.dumps([["text/plain", str(pos.title)]])),
+ "minSendable": price_msat,
+ "maxSendable": price_msat,
+ }
+ return json.dumps(payResponse)
+
+
+@lnurlpos_ext.get("/api/v1/lnurl/cb/{paymentid}")
+async def lnurl_callback(paymentid: str = Query(None)):
+ lnurlpospayment = await get_lnurlpospayment(paymentid)
+ pos = await get_lnurlpos(lnurlpospayment.posid)
+ if not pos:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN, detail="lnurlpos not found."
+ )
+ payment_hash, payment_request = await create_invoice(
+ wallet_id=pos.wallet,
+ amount=int(lnurlpospayment.sats / 1000),
+ memo=pos.title,
+ description_hash=hashlib.sha256(
+ (LnurlPayMetadata(json.dumps([["text/plain", str(pos.title)]]))).encode(
+ "utf-8"
+ )
+ ).digest(),
+ extra={"tag": "lnurlpos"},
+ )
+ lnurlpospayment = await update_lnurlpospayment(
+ lnurlpospayment_id=paymentid, payhash=payment_hash
+ )
+ success_action = pos.success_action(paymentid)
+
+ payResponse = {
+ "pr": payment_request,
+ "success_action": success_action,
+ "disposable": False,
+ "routes": [],
+ }
+ return json.dumps(payResponse)
diff --git a/lnbits/extensions/lnurlpos/migrations.py b/lnbits/extensions/lnurlpos/migrations.py
new file mode 100644
index 00000000..011cb4a3
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/migrations.py
@@ -0,0 +1,30 @@
+async def m001_initial(db):
+ """
+ Initial lnurlpos table.
+ """
+
+ await db.execute(
+ f"""
+ CREATE TABLE lnurlpos.lnurlposs (
+ id TEXT NOT NULL PRIMARY KEY,
+ key TEXT NOT NULL,
+ title TEXT NOT NULL,
+ wallet TEXT NOT NULL,
+ currency TEXT NOT NULL,
+ timestamp TIMESTAMP NOT NULL DEFAULT {db.timestamp_now}
+ );
+ """
+ )
+ await db.execute(
+ f"""
+ CREATE TABLE lnurlpos.lnurlpospayment (
+ id TEXT NOT NULL PRIMARY KEY,
+ posid TEXT NOT NULL,
+ payhash TEXT,
+ payload TEXT NOT NULL,
+ pin INT,
+ sats INT,
+ timestamp TIMESTAMP NOT NULL DEFAULT {db.timestamp_now}
+ );
+ """
+ )
diff --git a/lnbits/extensions/lnurlpos/models.py b/lnbits/extensions/lnurlpos/models.py
new file mode 100644
index 00000000..b6924593
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/models.py
@@ -0,0 +1,65 @@
+import json
+from lnurl import Lnurl, LnurlWithdrawResponse, encode as lnurl_encode # type: ignore
+from urllib.parse import urlparse, urlunparse, parse_qs, urlencode, ParseResult
+from lnurl.types import LnurlPayMetadata # type: ignore
+from sqlite3 import Row
+from typing import NamedTuple, Optional, Dict
+import shortuuid # type: ignore
+from fastapi.param_functions import Query
+from pydantic.main import BaseModel
+from pydantic import BaseModel
+from typing import Optional
+from fastapi import FastAPI, Request
+
+
+class createLnurlpos(BaseModel):
+ title: str
+ wallet: str
+ currency: str
+
+
+class lnurlposs(BaseModel):
+ id: str
+ key: str
+ title: str
+ wallet: str
+ currency: str
+ timestamp: str
+
+ @classmethod
+ def from_row(cls, row: Row) -> "lnurlposs":
+ return cls(**dict(row))
+
+ @property
+ def lnurl(self) -> Lnurl:
+ url = url_for("lnurlpos.lnurl_response", pos_id=self.id, _external=True)
+ return lnurl_encode(url)
+
+ @property
+ def lnurlpay_metadata(self) -> LnurlPayMetadata:
+ return LnurlPayMetadata(json.dumps([["text/plain", self.title]]))
+
+ def success_action(self, paymentid: str, req: Request) -> Optional[Dict]:
+ url = url_for(
+ "lnurlpos.displaypin",
+ paymentid=paymentid,
+ )
+ return {
+ "tag": "url",
+ "description": "Check the attached link",
+ "url": url,
+ }
+
+
+class lnurlpospayment(BaseModel):
+ id: str
+ posid: str
+ payhash: str
+ payload: str
+ pin: int
+ sats: int
+ timestamp: str
+
+ @classmethod
+ def from_row(cls, row: Row) -> "lnurlpospayment":
+ return cls(**dict(row))
diff --git a/lnbits/extensions/lnurlpos/templates/lnurlpos/_api_docs.html b/lnbits/extensions/lnurlpos/templates/lnurlpos/_api_docs.html
new file mode 100644
index 00000000..071d6d6c
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/templates/lnurlpos/_api_docs.html
@@ -0,0 +1,158 @@
+
+
+
+
+
+
+
+
+
+ {% endraw %}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Copy LndHub {{type}} URL
+
+
+
+
+
+
+
+ {% include "lndhub/_instructions.html" %}
+
+
+
+
++ {{SITE_TITLE}} LndHub extension +
+
+ Register LNURLPoS devices to recieve payments in your LNbits wallet.
+ Build your own here
+ https://github.com/arcbtc/LNURLPoS
+
+ Created by, Ben Arc
+
POST /lnurlpos/api/v1/lnurlpos
+ Headers
+{"X-Api-Key": <admin_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<lnurlpos_object>, ...]
+ Curl example
+curl -X POST {{ request.url_root }}api/v1/lnurlpos -d '{"title":
+ <string>, "message":<string>, "currency":
+ <integer>}' -H "Content-type: application/json" -H "X-Api-Key:
+ {{user.wallets[0].adminkey }}"
+
+ PUT
+ /lnurlpos/api/v1/lnurlpos/<lnurlpos_id>
+ Headers
+{"X-Api-Key": <admin_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<lnurlpos_object>, ...]
+ Curl example
+curl -X POST {{ request.url_root
+ }}api/v1/lnurlpos/<lnurlpos_id> -d ''{"title": <string>,
+ "message":<string>, "currency": <integer>} -H
+ "Content-type: application/json" -H "X-Api-Key:
+ {{user.wallets[0].adminkey }}"
+
+ GET
+ /lnurlpos/api/v1/lnurlpos/<lnurlpos_id>
+ Headers
+{"X-Api-Key": <invoice_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<lnurlpos_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root
+ }}api/v1/lnurlpos/<lnurlpos_id> -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ GET /lnurlpos/api/v1/lnurlposs
+ Headers
+{"X-Api-Key": <invoice_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<lnurlpos_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/lnurlposs -H "X-Api-Key:
+ {{ user.wallets[0].inkey }}"
+
+ DELETE
+ /lnurlpos/api/v1/lnurlpos/<lnurlpos_id>
+ Headers
+{"X-Api-Key": <admin_key>}+
Returns 204 NO CONTENT
+Curl example
+curl -X DELETE {{ request.url_root
+ }}api/v1/lnurlpos/<lnurlpos_id> -H "X-Api-Key: {{
+ user.wallets[0].adminkey }}"
+
+
+
diff --git a/lnbits/extensions/lnurlpos/templates/lnurlpos/index.html b/lnbits/extensions/lnurlpos/templates/lnurlpos/index.html
new file mode 100644
index 00000000..e6d8cd8f
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/templates/lnurlpos/index.html
@@ -0,0 +1,472 @@
+{% extends "base.html" %} {% from "macros.jinja" import window_vars with context
+%} {% block page %}
+
+
+
+
+
+
+
+
+
+
+
+ {% endblock %} {% block scripts %}
+
+
+
+ {% endblock %}
+LNURL-pay not paid
++
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+
+
+{% endblock %}
diff --git a/lnbits/extensions/lnurlpos/templates/lnurlpos/paid.html b/lnbits/extensions/lnurlpos/templates/lnurlpos/paid.html
new file mode 100644
index 00000000..c185ecce
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/templates/lnurlpos/paid.html
@@ -0,0 +1,27 @@
+{% extends "public.html" %} {% block page %}
+
+
+
+ {% raw %}
+ New LNURLPoS instance
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Delete LNURLPoS
+
+
+
+
+ LNURLPoS Settings
+
+
+
+
+
+
+
+ {% endraw %}
+
+
+
+
+
+
+
+
+
+
+ lNURLPoS
+
+
+
+
+ Export to CSV
+
+ {{ col.label }}
+ {{ col.value }}
+
+
+
+
+
+ {% include "lnurlpos/_api_docs.html" %}
+
+
+
+
+ + {{SITE_TITLE}} LNURLPoS Extension +
+Copy to LNURLPoS device
+
+ {% raw %} String server = "{{location}}";
+ String posId = "{{settingsDialog.data.id}}";
+ String key = "{{settingsDialog.data.key}}";
+ String currency = "{{settingsDialog.data.currency}}";{% endraw %} +
+ + String posId = "{{settingsDialog.data.id}}";
+ String key = "{{settingsDialog.data.key}}";
+ String currency = "{{settingsDialog.data.currency}}";{% endraw %} +
+ Update lnurlpos
+ Create lnurlpos
+ Cancel
+
+
+
diff --git a/lnbits/extensions/lnurlpos/views.py b/lnbits/extensions/lnurlpos/views.py
new file mode 100644
index 00000000..68e4ef06
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/views.py
@@ -0,0 +1,60 @@
+from http import HTTPStatus
+import httpx
+from collections import defaultdict
+from lnbits.decorators import check_user_exists
+
+from .crud import get_lnurlpos, get_lnurlpospayment
+from functools import wraps
+from lnbits.core.crud import get_standalone_payment
+import hashlib
+from lnbits.core.services import check_invoice_status
+from lnbits.core.crud import update_payment_status
+from fastapi import FastAPI, Request
+from fastapi.templating import Jinja2Templates
+from starlette.exceptions import HTTPException
+from starlette.responses import HTMLResponse
+from fastapi.params import Depends
+from fastapi.param_functions import Query
+import random
+
+from datetime import datetime
+from http import HTTPStatus
+from . import lnurlpos_ext, lnurlpos_renderer
+from lnbits.core.models import User, Payment
+
+templates = Jinja2Templates(directory="templates")
+
+
+@lnurlpos_ext.get("/")
+async def index(request: Request, user: User = Depends(check_user_exists)):
+ return lnurlpos_renderer().TemplateResponse(
+ "lnurlpos/index.html", {"request": request, "user": user.dict()}
+ )
+
+
+@lnurlpos_ext.get("/{paymentid}")
+async def displaypin(request: Request, paymentid: str = Query(None)):
+ lnurlpospayment = await get_lnurlpospayment(paymentid)
+ if not lnurlpospayment:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="No lmurlpos payment"
+ )
+ pos = await get_lnurlpos(lnurlpospayment.posid)
+ if not pos:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="lnurlpos not found."
+ )
+
+ status = await check_invoice_status(pos.wallet, lnurlpospayment.payhash)
+
+ is_paid = not status.pending
+ if not is_paid:
+ return lnurlpos_renderer().TemplateResponse(
+ "lnurlpos/error.html",
+ {"request": request, "pin": "filler", "not_paid": True},
+ )
+
+ await update_payment_status(checking_id=lnurlpospayment.payhash, pending=True)
+ return lnurlpos_renderer().TemplateResponse(
+ "lnurlpos/paid.html", {"request": request, "pin": lnurlpospayment.pin}
+ )
diff --git a/lnbits/extensions/lnurlpos/views_api.py b/lnbits/extensions/lnurlpos/views_api.py
new file mode 100644
index 00000000..21c8dd12
--- /dev/null
+++ b/lnbits/extensions/lnurlpos/views_api.py
@@ -0,0 +1,94 @@
+import hashlib
+from fastapi import FastAPI, Request
+from fastapi.params import Depends
+from http import HTTPStatus
+from fastapi.templating import Jinja2Templates
+from starlette.exceptions import HTTPException
+from starlette.responses import HTMLResponse
+from fastapi.params import Depends
+from fastapi.param_functions import Query
+from lnbits.decorators import check_user_exists, WalletTypeInfo, get_key_type
+from lnbits.core.crud import get_user
+from lnbits.core.models import User, Payment
+from . import lnurlpos_ext
+
+from lnbits.extensions.lnurlpos import lnurlpos_ext
+from .crud import (
+ create_lnurlpos,
+ update_lnurlpos,
+ get_lnurlpos,
+ get_lnurlposs,
+ delete_lnurlpos,
+)
+from lnbits.utils.exchange_rates import currencies
+from .models import createLnurlpos
+
+
+@lnurlpos_ext.get("/api/v1/currencies")
+async def api_list_currencies_available():
+ return list(currencies.keys())
+
+
+#######################lnurlpos##########################
+
+
+@lnurlpos_ext.post("/api/v1/lnurlpos")
+@lnurlpos_ext.put("/api/v1/lnurlpos/{lnurlpos_id}")
+async def api_lnurlpos_create_or_update(
+ request: Request,
+ data: createLnurlpos,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ lnurlpos_id: str = Query(None),
+):
+ if not lnurlpos_id:
+ lnurlpos = await create_lnurlpos(data)
+ print(lnurlpos.dict())
+ return lnurlpos.dict()
+ else:
+ lnurlpos = await update_lnurlpos(data, lnurlpos_id=lnurlpos_id)
+ return lnurlpos.dict()
+
+
+@lnurlpos_ext.get("/api/v1/lnurlpos")
+async def api_lnurlposs_retrieve(
+ request: Request, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+ wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids
+ try:
+ return [{**lnurlpos.dict()} for lnurlpos in await get_lnurlposs(wallet_ids)]
+ except:
+ return ""
+
+
+@lnurlpos_ext.get("/api/v1/lnurlpos/{lnurlpos_id}")
+async def api_lnurlpos_retrieve(
+ request: Request,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ lnurlpos_id: str = Query(None),
+):
+ lnurlpos = await get_lnurlpos(lnurlpos_id)
+ if not lnurlpos:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="lnurlpos does not exist"
+ )
+ if not lnurlpos.lnurl_toggle:
+ return {**lnurlpos.dict()}
+ return {**lnurlpos.dict(), **{"lnurl": lnurlpos.lnurl(request=request)}}
+
+
+@lnurlpos_ext.delete("/api/v1/lnurlpos/{lnurlpos_id}")
+async def api_lnurlpos_delete(
+ request: Request,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ lnurlpos_id: str = Query(None),
+):
+ lnurlpos = await get_lnurlpos(lnurlpos_id)
+
+ if not lnurlpos:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Wallet link does not exist."
+ )
+
+ await delete_lnurlpos(lnurlpos_id)
+
+ return "", HTTPStatus.NO_CONTENT
diff --git a/lnbits/extensions/ngrok/README.md b/lnbits/extensions/ngrok/README.md
new file mode 100644
index 00000000..626c788f
--- /dev/null
+++ b/lnbits/extensions/ngrok/README.md
@@ -0,0 +1,24 @@
+
+
+
+
+
+
+
+
+
+
+ {% endblock %} {% block scripts %}
+
+
+
+ {% endblock %}
+{{ pin }}
++
Ngrok
+Serve lnbits over https for free using ngrok
+ +
+
+How it works
+ +When enabled, ngrok creates a tunnel to ngrok.io with https support and tells you the https web address where you can access your lnbits instance. If you are not the first user to enable it, it doesn't create a new one, it just tells you the existing one. Useful for creating/managing/using lnurls, which must be served either via https or via tor. Note that if you restart your device, your device will generate a new url. If anyone is using your old one for wallets, lnurls, etc., whatever they are doing will stop working. + +Installation
+ +Check the Extensions page on your instance of lnbits. If you have copy of lnbits with ngrok as one of the built in extensions, click Enable -- that's the only thing you need to do to install it. + +If your copy of lnbits does not have ngrok as one of the built in extensions, stop lnbits, create go into your lnbits folder, and run this command: ./venv/bin/pip install pyngrok. Then go into the lnbits subdirectory and the extensions subdirectory within that. (So lnbits > lnbits > extensions.) Create a new subdirectory in there called freetunnel, download this repository as a zip file, and unzip it in the freetunnel directory. If your unzipper creates a new "freetunnel" subdirectory, take everything out of there and put it in the freetunnel directory you created. Then go back to the top level lnbits directory and run these commands: + +``` +./venv/bin/quart assets +./venv/bin/quart migrate +./venv/bin/hypercorn -k trio --bind 0.0.0.0:5000 'lnbits.app:create_app()' +``` + +Optional: set up an ngrok.com account
+ +The default setup makes a tunnel on a random subdomain, and the session times out after 24h or a certain bandwith limit. You can set up an account at ngrok.com; a free plan removes the timeout, and a paid plan lets you choose a custom subdomain (or even use your own domain). For this, get an auth token from ngrok.com, and then set it up as `NGROK_AUTHTOKEN` environment variable on your `.env` file e.g., if your auth token is xxxx, add a line NGROK_AUTHTOKEN=xxxx. diff --git a/lnbits/extensions/ngrok/__init__.py b/lnbits/extensions/ngrok/__init__.py new file mode 100644 index 00000000..a60414a3 --- /dev/null +++ b/lnbits/extensions/ngrok/__init__.py @@ -0,0 +1,18 @@ +import asyncio +from fastapi import APIRouter, FastAPI +from fastapi.staticfiles import StaticFiles +from starlette.routing import Mount +from lnbits.db import Database +from lnbits.helpers import template_renderer +from lnbits.tasks import catch_everything_and_restart + +db = Database("ext_ngrok") + +ngrok_ext: APIRouter = APIRouter(prefix="/ngrok", tags=["ngrok"]) + + +def ngrok_renderer(): + return template_renderer(["lnbits/extensions/ngrok/templates"]) + + +from .views import * diff --git a/lnbits/extensions/ngrok/config.json b/lnbits/extensions/ngrok/config.json new file mode 100644 index 00000000..58e9ff8e --- /dev/null +++ b/lnbits/extensions/ngrok/config.json @@ -0,0 +1,6 @@ +{ + "name": "Ngrok", + "short_description": "Serve lnbits over https for free using ngrok", + "icon": "trip_origin", + "contributors": ["supertestnet"] +} diff --git a/lnbits/extensions/ngrok/migrations.py b/lnbits/extensions/ngrok/migrations.py new file mode 100644 index 00000000..f9b8b37d --- /dev/null +++ b/lnbits/extensions/ngrok/migrations.py @@ -0,0 +1,11 @@ +# async def m001_initial(db): + +# await db.execute( +# """ +# CREATE TABLE example.example ( +# id TEXT PRIMARY KEY, +# wallet TEXT NOT NULL, +# time TIMESTAMP NOT NULL DEFAULT """ + db.timestamp_now + """ +# ); +# """ +# ) diff --git a/lnbits/extensions/ngrok/templates/ngrok/index.html b/lnbits/extensions/ngrok/templates/ngrok/index.html new file mode 100644 index 00000000..3af4fa44 --- /dev/null +++ b/lnbits/extensions/ngrok/templates/ngrok/index.html @@ -0,0 +1,53 @@ +{% extends "base.html" %} {% from "macros.jinja" import window_vars with context +%} {% block page %} + +
+
+
+{% endblock %}{% block scripts %} {{ window_vars(user) }}
+
+{% endblock %}
diff --git a/lnbits/extensions/ngrok/views.py b/lnbits/extensions/ngrok/views.py
new file mode 100644
index 00000000..8b3fe0dd
--- /dev/null
+++ b/lnbits/extensions/ngrok/views.py
@@ -0,0 +1,44 @@
+from http import HTTPStatus
+
+from lnbits.decorators import check_user_exists
+
+from . import ngrok_ext, ngrok_renderer
+from fastapi import FastAPI, Request
+from fastapi.params import Depends
+from fastapi.templating import Jinja2Templates
+
+from starlette.exceptions import HTTPException
+from starlette.responses import HTMLResponse
+from lnbits.core.models import User
+from os import getenv
+from pyngrok import conf, ngrok
+
+templates = Jinja2Templates(directory="templates")
+
+
+def log_event_callback(log):
+ string = str(log)
+ print(string)
+ string2 = string[string.find('url="https') : string.find('url="https') + 80]
+ if string2:
+ string3 = string2
+ string4 = string3[4:]
+ global string5
+ string5 = string4.replace('"', "")
+
+
+conf.get_default().log_event_callback = log_event_callback
+
+ngrok_authtoken = getenv("NGROK_AUTHTOKEN")
+if ngrok_authtoken is not None:
+ ngrok.set_auth_token(ngrok_authtoken)
+
+port = getenv("PORT")
+ngrok_tunnel = ngrok.connect(port)
+
+
+@ngrok_ext.get("/")
+async def index(request: Request, user: User = Depends(check_user_exists)):
+ return ngrok_renderer().TemplateResponse(
+ "ngrok/index.html", {"request": request, "ngrok": string5, "user": user.dict()}
+ )
diff --git a/lnbits/extensions/offlineshop/__init__.py b/lnbits/extensions/offlineshop/__init__.py
index d0912a64..0cc3201d 100644
--- a/lnbits/extensions/offlineshop/__init__.py
+++ b/lnbits/extensions/offlineshop/__init__.py
@@ -29,11 +29,7 @@ offlineshop_ext: APIRouter = APIRouter(
def offlineshop_renderer():
- return template_renderer(
- [
- "lnbits/extensions/offlineshop/templates",
- ]
- )
+ return template_renderer(["lnbits/extensions/offlineshop/templates"])
from .lnurl import * # noqa
diff --git a/lnbits/extensions/offlineshop/crud.py b/lnbits/extensions/offlineshop/crud.py
index 2ee931cd..0ecb3d52 100644
--- a/lnbits/extensions/offlineshop/crud.py
+++ b/lnbits/extensions/offlineshop/crud.py
@@ -51,12 +51,7 @@ async def set_method(shop: int, method: str, wordlist: str = "") -> Optional[Sho
async def add_item(
- shop: int,
- name: str,
- description: str,
- image: Optional[str],
- price: int,
- unit: str,
+ shop: int, name: str, description: str, image: Optional[str], price: int, unit: str
) -> int:
result = await db.execute(
"""
diff --git a/lnbits/extensions/offlineshop/helpers.py b/lnbits/extensions/offlineshop/helpers.py
index db2c19cc..6b56cf55 100644
--- a/lnbits/extensions/offlineshop/helpers.py
+++ b/lnbits/extensions/offlineshop/helpers.py
@@ -8,8 +8,8 @@ def hotp(key, counter, digits=6, digest="sha1"):
key = base64.b32decode(key.upper() + "=" * ((8 - len(key)) % 8))
counter = struct.pack(">Q", counter)
mac = hmac.new(key, counter, digest).digest()
- offset = mac[-1] & 0x0f
- binary = struct.unpack(">L", mac[offset : offset + 4])[0] & 0x7fffffff
+ offset = mac[-1] & 0x0F
+ binary = struct.unpack(">L", mac[offset : offset + 4])[0] & 0x7FFFFFFF
return str(binary)[-digits:].zfill(digits)
diff --git a/lnbits/extensions/offlineshop/lnurl.py b/lnbits/extensions/offlineshop/lnurl.py
index b04d8512..ea576f1d 100644
--- a/lnbits/extensions/offlineshop/lnurl.py
+++ b/lnbits/extensions/offlineshop/lnurl.py
@@ -4,7 +4,11 @@ from fastapi.params import Query
from starlette.requests import Request
from lnbits.helpers import url_for
-from lnurl import LnurlPayResponse, LnurlPayActionResponse, LnurlErrorResponse # type: ignore
+from lnurl import (
+ LnurlPayResponse,
+ LnurlPayActionResponse,
+ LnurlErrorResponse,
+) # type: ignore
from lnbits.core.services import create_invoice
from lnbits.utils.exchange_rates import fiat_amount_as_satoshis
@@ -15,7 +19,7 @@ from .crud import get_shop, get_item
@offlineshop_ext.get("/lnurl/{item_id}", name="offlineshop.lnurl_response")
async def lnurl_response(req: Request, item_id: int = Query(...)):
- item = await get_item(item_id) # type: Item
+ item = await get_item(item_id) # type: Item
if not item:
return {"status": "ERROR", "reason": "Item not found."}
@@ -40,7 +44,7 @@ async def lnurl_response(req: Request, item_id: int = Query(...)):
@offlineshop_ext.get("/lnurl/cb/{item_id}", name="offlineshop.lnurl_callback")
async def lnurl_callback(request: Request, item_id: int):
- item = await get_item(item_id) # type: Item
+ item = await get_item(item_id) # type: Item
if not item:
return {"status": "ERROR", "reason": "Couldn't find item."}
@@ -80,7 +84,9 @@ async def lnurl_callback(request: Request, item_id: int):
resp = LnurlPayActionResponse(
pr=payment_request,
- success_action=item.success_action(shop, payment_hash, request) if shop.method else None,
+ success_action=item.success_action(shop, payment_hash, request)
+ if shop.method
+ else None,
routes=[],
)
diff --git a/lnbits/extensions/offlineshop/models.py b/lnbits/extensions/offlineshop/models.py
index 12616022..06225351 100644
--- a/lnbits/extensions/offlineshop/models.py
+++ b/lnbits/extensions/offlineshop/models.py
@@ -14,7 +14,7 @@ from .helpers import totp
shop_counters: Dict = {}
-class ShopCounter():
+class ShopCounter:
wordlist: List[str]
fulfilled_payments: OrderedDict
counter: int
@@ -66,7 +66,7 @@ class Shop(BaseModel):
def otp_key(self) -> str:
return base64.b32encode(
hashlib.sha256(
- ("otpkey" + str(self.id) + self.wallet).encode("ascii"),
+ ("otpkey" + str(self.id) + self.wallet).encode("ascii")
).digest()
).decode("ascii")
@@ -90,9 +90,7 @@ class Item(BaseModel):
unit: str
def lnurl(self, req: Request) -> str:
- return lnurl_encode(
- req.url_for("offlineshop.lnurl_response", item_id=self.id)
- )
+ return lnurl_encode(req.url_for("offlineshop.lnurl_response", item_id=self.id))
def values(self, req: Request):
values = self.dict()
@@ -116,8 +114,6 @@ class Item(BaseModel):
return None
return UrlAction(
- url=req.url_for(
- "offlineshop.confirmation_code", p=payment_hash
- ),
+ url=req.url_for("offlineshop.confirmation_code", p=payment_hash),
description="Open to get the confirmation code for your purchase.",
)
diff --git a/lnbits/extensions/offlineshop/views.py b/lnbits/extensions/offlineshop/views.py
index e8bea173..748d2024 100644
--- a/lnbits/extensions/offlineshop/views.py
+++ b/lnbits/extensions/offlineshop/views.py
@@ -18,14 +18,16 @@ from fastapi import Request, HTTPException
@offlineshop_ext.get("/", response_class=HTMLResponse)
async def index(request: Request, user: User = Depends(check_user_exists)):
- return offlineshop_renderer().TemplateResponse("offlineshop/index.html", {"request": request, "user": user.dict()})
+ return offlineshop_renderer().TemplateResponse(
+ "offlineshop/index.html", {"request": request, "user": user.dict()}
+ )
@offlineshop_ext.get("/print", response_class=HTMLResponse)
async def print_qr_codes(request: Request, items: List[int] = None):
items = []
for item_id in request.query_params.get("items").split(","):
- item = await get_item(item_id) # type: Item
+ item = await get_item(item_id) # type: Item
if item:
items.append(
{
@@ -35,11 +37,16 @@ async def print_qr_codes(request: Request, items: List[int] = None):
}
)
- return offlineshop_renderer().TemplateResponse("offlineshop/print.html", {"request": request,"items":items})
+ return offlineshop_renderer().TemplateResponse(
+ "offlineshop/print.html", {"request": request, "items": items}
+ )
-@offlineshop_ext.get("/confirmation/{p}", name="offlineshop.confirmation_code",
- response_class=HTMLResponse)
+@offlineshop_ext.get(
+ "/confirmation/{p}",
+ name="offlineshop.confirmation_code",
+ response_class=HTMLResponse,
+)
async def confirmation_code(p: str = Query(...)):
style = ""
@@ -48,20 +55,20 @@ async def confirmation_code(p: str = Query(...)):
if not payment:
raise HTTPException(
status_code=HTTPStatus.NOT_FOUND,
- detail=f"Couldn't find the payment {payment_hash}." + style
+ detail=f"Couldn't find the payment {payment_hash}." + style,
)
if payment.pending:
raise HTTPException(
status_code=HTTPStatus.PAYMENT_REQUIRED,
- detail=f"Payment {payment_hash} wasn't received yet. Please try again in a minute." + style
+ detail=f"Payment {payment_hash} wasn't received yet. Please try again in a minute."
+ + style,
)
if payment.time + 60 * 15 < time.time():
raise HTTPException(
status_code=HTTPStatus.REQUEST_TIMEOUT,
- detail="Too much time has passed." + style
+ detail="Too much time has passed." + style,
)
-
item = await get_item(payment.extra.get("item"))
shop = await get_shop(item.shop)
diff --git a/lnbits/extensions/offlineshop/views_api.py b/lnbits/extensions/offlineshop/views_api.py
index 58b95935..f3968948 100644
--- a/lnbits/extensions/offlineshop/views_api.py
+++ b/lnbits/extensions/offlineshop/views_api.py
@@ -33,17 +33,16 @@ async def api_list_currencies_available():
@offlineshop_ext.get("/api/v1/offlineshop")
# @api_check_wallet_key("invoice")
-async def api_shop_from_wallet(r: Request, wallet: WalletTypeInfo = Depends(get_key_type)):
+async def api_shop_from_wallet(
+ r: Request, wallet: WalletTypeInfo = Depends(get_key_type)
+):
shop = await get_or_create_shop_by_wallet(wallet.wallet.id)
items = await get_items(shop.id)
try:
return {
**shop.dict(),
- **{
- "otp_key": shop.otp_key,
- "items": [item.values(r) for item in items],
- },
+ **{"otp_key": shop.otp_key, "items": [item.values(r) for item in items]},
}
except LnurlInvalidUrl:
raise HTTPException(
@@ -63,18 +62,15 @@ class CreateItemsData(BaseModel):
@offlineshop_ext.post("/api/v1/offlineshop/items")
@offlineshop_ext.put("/api/v1/offlineshop/items/{item_id}")
# @api_check_wallet_key("invoice")
-async def api_add_or_update_item(data: CreateItemsData, item_id=None, wallet: WalletTypeInfo = Depends(get_key_type)):
+async def api_add_or_update_item(
+ data: CreateItemsData, item_id=None, wallet: WalletTypeInfo = Depends(get_key_type)
+):
shop = await get_or_create_shop_by_wallet(wallet.wallet.id)
if item_id == None:
await add_item(
- shop.id,
- data.name,
- data.description,
- data.image,
- data.price,
- data.unit,
+ shop.id, data.name, data.description, data.image, data.price, data.unit
)
- return HTMLResponse(status_code=HTTPStatus.CREATED)
+ return HTMLResponse(status_code=HTTPStatus.CREATED)
else:
await update_item(
shop.id,
@@ -102,7 +98,9 @@ class CreateMethodData(BaseModel):
@offlineshop_ext.put("/api/v1/offlineshop/method")
# @api_check_wallet_key("invoice")
-async def api_set_method(data: CreateMethodData, wallet: WalletTypeInfo = Depends(get_key_type)):
+async def api_set_method(
+ data: CreateMethodData, wallet: WalletTypeInfo = Depends(get_key_type)
+):
method = data.method
wordlist = data.wordlist.split("\n") if data.wordlist else None
diff --git a/lnbits/extensions/satsdice/README.md b/lnbits/extensions/satsdice/README.md
new file mode 100644
index 00000000..c2419930
--- /dev/null
+++ b/lnbits/extensions/satsdice/README.md
@@ -0,0 +1,5 @@
+# satsdice
+
+## Create staic LNURL powered satsdices
+
+Gambling is dangerous, flip responsibly
diff --git a/lnbits/extensions/satsdice/__init__.py b/lnbits/extensions/satsdice/__init__.py
new file mode 100644
index 00000000..5a645618
--- /dev/null
+++ b/lnbits/extensions/satsdice/__init__.py
@@ -0,0 +1,25 @@
+import asyncio
+from fastapi import APIRouter, FastAPI
+from fastapi.staticfiles import StaticFiles
+from starlette.routing import Mount
+from lnbits.db import Database
+from lnbits.helpers import template_renderer
+from lnbits.tasks import catch_everything_and_restart
+
+db = Database("ext_satsdice")
+
+satsdice_ext: APIRouter = APIRouter(prefix="/satsdice", tags=["satsdice"])
+
+
+def satsdice_renderer():
+ return template_renderer(["lnbits/extensions/satsdice/templates"])
+
+
+from .views_api import * # noqa
+from .views import * # noqa
+from .lnurl import * # noqa
+
+
+# def satsdice_start():
+# loop = asyncio.get_event_loop()
+# loop.create_task(catch_everything_and_restart(wait_for_paid_invoices))
diff --git a/lnbits/extensions/satsdice/config.json b/lnbits/extensions/satsdice/config.json
new file mode 100644
index 00000000..e4c2eddb
--- /dev/null
+++ b/lnbits/extensions/satsdice/config.json
@@ -0,0 +1,6 @@
+{
+ "name": "Sats Dice",
+ "short_description": "LNURL Satoshi dice",
+ "icon": "casino",
+ "contributors": ["arcbtc"]
+}
diff --git a/lnbits/extensions/satsdice/crud.py b/lnbits/extensions/satsdice/crud.py
new file mode 100644
index 00000000..4fd3c8c2
--- /dev/null
+++ b/lnbits/extensions/satsdice/crud.py
@@ -0,0 +1,285 @@
+from datetime import datetime
+from typing import List, Optional, Union
+from lnbits.helpers import urlsafe_short_hash
+from typing import List, Optional
+from . import db
+from .models import (
+ satsdiceWithdraw,
+ HashCheck,
+ satsdiceLink,
+ satsdicePayment,
+ CreateSatsDiceLink,
+ CreateSatsDicePayment,
+ CreateSatsDiceWithdraw,
+)
+from lnbits.helpers import urlsafe_short_hash
+
+
+async def create_satsdice_pay(
+ data: CreateSatsDiceLink,
+) -> satsdiceLink:
+ satsdice_id = urlsafe_short_hash()
+ await db.execute(
+ """
+ INSERT INTO satsdice.satsdice_pay (
+ id,
+ wallet,
+ title,
+ base_url,
+ min_bet,
+ max_bet,
+ amount,
+ served_meta,
+ served_pr,
+ multiplier,
+ chance,
+ haircut,
+ open_time
+ )
+ VALUES (?, ?, ?, ?, ?, ?, 0, 0, 0, ?, ?, ?, ?)
+ """,
+ (
+ satsdice_id,
+ data.wallet_id,
+ data.title,
+ data.base_url,
+ data.min_bet,
+ data.max_bet,
+ data.multiplier,
+ data.chance,
+ data.haircut,
+ int(datetime.now().timestamp()),
+ ),
+ )
+ link = await get_satsdice_pay(satsdice_id)
+ assert link, "Newly created link couldn't be retrieved"
+ return link
+
+
+async def get_satsdice_pay(link_id: str) -> Optional[satsdiceLink]:
+ row = await db.fetchone(
+ "SELECT * FROM satsdice.satsdice_pay WHERE id = ?", (link_id,)
+ )
+ return satsdiceLink(**row) if row else None
+
+
+async def get_satsdice_pays(wallet_ids: Union[str, List[str]]) -> List[satsdiceLink]:
+ if isinstance(wallet_ids, str):
+ wallet_ids = [wallet_ids]
+ print("wallet_ids")
+ print(wallet_ids)
+ print("wallet_ids")
+
+ q = ",".join(["?"] * len(wallet_ids))
+ rows = await db.fetchall(
+ f"""
+ SELECT * FROM satsdice.satsdice_pay WHERE wallet IN ({q})
+ ORDER BY id
+ """,
+ (*wallet_ids,),
+ )
+ return [satsdiceLink(**row) for row in rows]
+
+
+async def update_satsdice_pay(link_id: int, **kwargs) -> Optional[satsdiceLink]:
+ q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
+ await db.execute(
+ f"UPDATE satsdice.satsdice_pay SET {q} WHERE id = ?",
+ (*kwargs.values(), link_id),
+ )
+ row = await db.fetchone(
+ "SELECT * FROM satsdice.satsdice_pay WHERE id = ?", (link_id,)
+ )
+ return satsdiceLink(**row) if row else None
+
+
+async def increment_satsdice_pay(link_id: int, **kwargs) -> Optional[satsdiceLink]:
+ q = ", ".join([f"{field[0]} = {field[0]} + ?" for field in kwargs.items()])
+ await db.execute(
+ f"UPDATE satsdice.satsdice_pay SET {q} WHERE id = ?",
+ (*kwargs.values(), link_id),
+ )
+ row = await db.fetchone(
+ "SELECT * FROM satsdice.satsdice_pay WHERE id = ?", (link_id,)
+ )
+ return satsdiceLink(**row) if row else None
+
+
+async def delete_satsdice_pay(link_id: int) -> None:
+ await db.execute("DELETE FROM satsdice.satsdice_pay WHERE id = ?", (link_id,))
+
+
+##################SATSDICE PAYMENT LINKS
+
+
+async def create_satsdice_payment(data: CreateSatsDicePayment) -> satsdicePayment:
+ await db.execute(
+ """
+ INSERT INTO satsdice.satsdice_payment (
+ payment_hash,
+ satsdice_pay,
+ value,
+ paid,
+ lost
+ )
+ VALUES (?, ?, ?, ?, ?)
+ """,
+ (data["payment_hash"], data["satsdice_pay"], data["value"], False, False),
+ )
+ payment = await get_satsdice_payment(data["payment_hash"])
+ assert payment, "Newly created withdraw couldn't be retrieved"
+ return payment
+
+
+async def get_satsdice_payment(payment_hash: str) -> Optional[satsdicePayment]:
+ row = await db.fetchone(
+ "SELECT * FROM satsdice.satsdice_payment WHERE payment_hash = ?",
+ (payment_hash,),
+ )
+ return satsdicePayment(**row) if row else None
+
+
+async def update_satsdice_payment(
+ payment_hash: int, **kwargs
+) -> Optional[satsdicePayment]:
+ q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
+
+ await db.execute(
+ f"UPDATE satsdice.satsdice_payment SET {q} WHERE payment_hash = ?",
+ (bool(*kwargs.values()), payment_hash),
+ )
+ row = await db.fetchone(
+ "SELECT * FROM satsdice.satsdice_payment WHERE payment_hash = ?",
+ (payment_hash,),
+ )
+ return satsdicePayment(**row) if row else None
+
+
+##################SATSDICE WITHDRAW LINKS
+
+
+async def create_satsdice_withdraw(data: CreateSatsDiceWithdraw) -> satsdiceWithdraw:
+ await db.execute(
+ """
+ INSERT INTO satsdice.satsdice_withdraw (
+ id,
+ satsdice_pay,
+ value,
+ unique_hash,
+ k1,
+ open_time,
+ used
+ )
+ VALUES (?, ?, ?, ?, ?, ?, ?)
+ """,
+ (
+ data["payment_hash"],
+ data["satsdice_pay"],
+ data["value"],
+ urlsafe_short_hash(),
+ urlsafe_short_hash(),
+ int(datetime.now().timestamp()),
+ data["used"],
+ ),
+ )
+ withdraw = await get_satsdice_withdraw(data["payment_hash"], 0)
+ assert withdraw, "Newly created withdraw couldn't be retrieved"
+ return withdraw
+
+
+async def get_satsdice_withdraw(withdraw_id: str, num=0) -> Optional[satsdiceWithdraw]:
+ row = await db.fetchone(
+ "SELECT * FROM satsdice.satsdice_withdraw WHERE id = ?", (withdraw_id,)
+ )
+ if not row:
+ return None
+
+ withdraw = []
+ for item in row:
+ withdraw.append(item)
+ withdraw.append(num)
+ return satsdiceWithdraw(**row)
+
+
+async def get_satsdice_withdraw_by_hash(
+ unique_hash: str, num=0
+) -> Optional[satsdiceWithdraw]:
+ row = await db.fetchone(
+ "SELECT * FROM satsdice.satsdice_withdraw WHERE unique_hash = ?", (unique_hash,)
+ )
+ if not row:
+ return None
+
+ withdraw = []
+ for item in row:
+ withdraw.append(item)
+ withdraw.append(num)
+ return satsdiceWithdraw(**row)
+
+
+async def get_satsdice_withdraws(
+ wallet_ids: Union[str, List[str]]
+) -> List[satsdiceWithdraw]:
+ if isinstance(wallet_ids, str):
+ wallet_ids = [wallet_ids]
+
+ q = ",".join(["?"] * len(wallet_ids))
+ rows = await db.fetchall(
+ f"SELECT * FROM satsdice.satsdice_withdraw WHERE wallet IN ({q})",
+ (*wallet_ids,),
+ )
+
+ return [satsdiceWithdraw(**row) for row in rows]
+
+
+async def update_satsdice_withdraw(
+ withdraw_id: str, **kwargs
+) -> Optional[satsdiceWithdraw]:
+ q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
+ await db.execute(
+ f"UPDATE satsdice.satsdice_withdraw SET {q} WHERE id = ?",
+ (*kwargs.values(), withdraw_id),
+ )
+ row = await db.fetchone(
+ "SELECT * FROM satsdice.satsdice_withdraw WHERE id = ?", (withdraw_id,)
+ )
+ return satsdiceWithdraw(**row) if row else None
+
+
+async def delete_satsdice_withdraw(withdraw_id: str) -> None:
+ await db.execute(
+ "DELETE FROM satsdice.satsdice_withdraw WHERE id = ?", (withdraw_id,)
+ )
+
+
+async def create_withdraw_hash_check(the_hash: str, lnurl_id: str) -> HashCheck:
+ await db.execute(
+ """
+ INSERT INTO satsdice.hash_checkw (
+ id,
+ lnurl_id
+ )
+ VALUES (?, ?)
+ """,
+ (the_hash, lnurl_id),
+ )
+ hashCheck = await get_withdraw_hash_checkw(the_hash, lnurl_id)
+ return hashCheck
+
+
+async def get_withdraw_hash_checkw(the_hash: str, lnurl_id: str) -> Optional[HashCheck]:
+ rowid = await db.fetchone(
+ "SELECT * FROM satsdice.hash_checkw WHERE id = ?", (the_hash,)
+ )
+ rowlnurl = await db.fetchone(
+ "SELECT * FROM satsdice.hash_checkw WHERE lnurl_id = ?", (lnurl_id,)
+ )
+ if not rowlnurl:
+ await create_withdraw_hash_check(the_hash, lnurl_id)
+ return {"lnurl": True, "hash": False}
+ else:
+ if not rowid:
+ await create_withdraw_hash_check(the_hash, lnurl_id)
+ return {"lnurl": True, "hash": False}
+ else:
+ return {"lnurl": True, "hash": True}
diff --git a/lnbits/extensions/satsdice/lnurl.py b/lnbits/extensions/satsdice/lnurl.py
new file mode 100644
index 00000000..1d46f054
--- /dev/null
+++ b/lnbits/extensions/satsdice/lnurl.py
@@ -0,0 +1,199 @@
+import shortuuid # type: ignore
+import hashlib
+import math
+import json
+from http import HTTPStatus
+from datetime import datetime
+from lnbits.core.services import pay_invoice, create_invoice
+from http import HTTPStatus
+from starlette.exceptions import HTTPException
+from starlette.responses import HTMLResponse, JSONResponse # type: ignore
+from lnbits.utils.exchange_rates import get_fiat_rate_satoshis
+from fastapi import FastAPI, Request
+from fastapi.params import Depends
+from typing import Optional
+from fastapi.param_functions import Query
+from . import satsdice_ext
+from .crud import (
+ get_satsdice_withdraw_by_hash,
+ update_satsdice_withdraw,
+ get_satsdice_pay,
+ create_satsdice_payment,
+)
+from lnurl import (
+ LnurlPayResponse,
+ LnurlPayActionResponse,
+ LnurlErrorResponse,
+)
+from .models import CreateSatsDicePayment
+
+
+##############LNURLP STUFF
+
+
+@satsdice_ext.get(
+ "/api/v1/lnurlp/{link_id}",
+ response_class=HTMLResponse,
+ name="satsdice.lnurlp_response",
+)
+async def api_lnurlp_response(req: Request, link_id: str = Query(None)):
+ link = await get_satsdice_pay(link_id)
+ if not link:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="LNURL-pay not found."
+ )
+ payResponse = {
+ "tag": "payRequest",
+ "callback": req.url_for("satsdice.api_lnurlp_callback", link_id=link.id),
+ "metadata": link.lnurlpay_metadata,
+ "minSendable": math.ceil(link.min_bet * 1) * 1000,
+ "maxSendable": round(link.max_bet * 1) * 1000,
+ }
+ return json.dumps(payResponse)
+
+
+@satsdice_ext.get(
+ "/api/v1/lnurlp/cb/{link_id}",
+ response_class=HTMLResponse,
+ name="satsdice.api_lnurlp_callback",
+)
+async def api_lnurlp_callback(
+ req: Request,
+ link_id: str = Query(None),
+ amount: str = Query(None),
+):
+ link = await get_satsdice_pay(link_id)
+ print(link)
+ if not link:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="LNURL-pay not found."
+ )
+
+ min, max = link.min_bet, link.max_bet
+ min = link.min_bet * 1000
+ max = link.max_bet * 1000
+
+ amount_received = int(amount or 0)
+ if amount_received < min:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN,
+ detail=f"Amount {amount_received} is smaller than minimum {min}.",
+ )
+ elif amount_received > max:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN,
+ detail=f"Amount {amount_received} is greater than maximum {max}.",
+ )
+
+ payment_hash, payment_request = await create_invoice(
+ wallet_id=link.wallet,
+ amount=int(amount_received / 1000),
+ memo="Satsdice bet",
+ description_hash=hashlib.sha256(
+ link.lnurlpay_metadata.encode("utf-8")
+ ).digest(),
+ extra={"tag": "satsdice", "link": link.id, "comment": "comment"},
+ )
+
+ success_action = link.success_action(payment_hash=payment_hash, req=req)
+
+ data: CreateSatsDicePayment = {
+ "satsdice_pay": link.id,
+ "value": amount_received / 1000,
+ "payment_hash": payment_hash,
+ }
+
+ await create_satsdice_payment(data)
+ payResponse = {
+ "pr": payment_request,
+ "successAction": success_action,
+ "routes": [],
+ }
+ print(json.dumps(payResponse))
+
+ return json.dumps(payResponse)
+
+
+##############LNURLW STUFF
+
+
+@satsdice_ext.get(
+ "/api/v1/lnurlw/{unique_hash}",
+ response_class=HTMLResponse,
+ name="satsdice.lnurlw_response",
+)
+async def api_lnurlw_response(req: Request, unique_hash: str = Query(None)):
+ link = await get_satsdice_withdraw_by_hash(unique_hash)
+
+ if not link:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="LNURL-satsdice not found."
+ )
+ if link.used:
+ raise HTTPException(status_code=HTTPStatus.OK, detail="satsdice is spent.")
+ url = req.url_for("satsdice.api_lnurlw_callback", unique_hash=link.unique_hash)
+ withdrawResponse = {
+ "tag": "withdrawRequest",
+ "callback": url,
+ "k1": link.k1,
+ "minWithdrawable": link.value * 1000,
+ "maxWithdrawable": link.value * 1000,
+ "defaultDescription": "Satsdice winnings!",
+ }
+ return json.dumps(withdrawResponse)
+
+
+# CALLBACK
+
+
+@satsdice_ext.get(
+ "/api/v1/lnurlw/cb/{unique_hash}",
+ response_class=HTMLResponse,
+ name="satsdice.api_lnurlw_callback",
+)
+async def api_lnurlw_callback(
+ req: Request,
+ unique_hash: str = Query(None),
+ k1: str = Query(None),
+ pr: str = Query(None),
+):
+ link = await get_satsdice_withdraw_by_hash(unique_hash)
+ paylink = await get_satsdice_pay(link.satsdice_pay)
+ payment_request = pr
+ now = int(datetime.now().timestamp())
+
+ if not link:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="LNURL-satsdice not found."
+ )
+
+ if link.used:
+ raise HTTPException(status_code=HTTPStatus.OK, detail="satsdice is spent.")
+
+ if link.k1 != k1:
+ raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="Bad request..")
+
+ if now < link.open_time:
+ return {"status": "ERROR", "reason": f"Wait {link.open_time - now} seconds."}
+
+ try:
+ await update_satsdice_withdraw(link.id, used=1)
+
+ await pay_invoice(
+ wallet_id=paylink.wallet,
+ payment_request=payment_request,
+ max_sat=link.value,
+ extra={"tag": "withdraw"},
+ )
+
+ except ValueError as e:
+ await update_satsdice_withdraw(link.id, used=1)
+ return {"status": "ERROR", "reason": str(e)}
+ except PermissionError:
+ await update_satsdice_withdraw(link.id, used=1)
+ return {"status": "ERROR", "reason": "satsdice link is empty."}
+ except Exception as e:
+ await update_satsdice_withdraw(link.id, used=1)
+ return {"status": "ERROR", "reason": str(e)}
+
+ return {"status": "OK"}
diff --git a/lnbits/extensions/satsdice/migrations.py b/lnbits/extensions/satsdice/migrations.py
new file mode 100644
index 00000000..61298241
--- /dev/null
+++ b/lnbits/extensions/satsdice/migrations.py
@@ -0,0 +1,73 @@
+async def m001_initial(db):
+ """
+ Creates an improved satsdice table and migrates the existing data.
+ """
+ await db.execute(
+ """
+ CREATE TABLE satsdice.satsdice_pay (
+ id TEXT PRIMARY KEY,
+ wallet TEXT,
+ title TEXT,
+ min_bet INTEGER,
+ max_bet INTEGER,
+ amount INTEGER DEFAULT 0,
+ served_meta INTEGER NOT NULL,
+ served_pr INTEGER NOT NULL,
+ multiplier FLOAT,
+ haircut FLOAT,
+ chance FLOAT,
+ base_url TEXT,
+ open_time INTEGER
+ );
+ """
+ )
+
+
+async def m002_initial(db):
+ """
+ Creates an improved satsdice table and migrates the existing data.
+ """
+ await db.execute(
+ """
+ CREATE TABLE satsdice.satsdice_withdraw (
+ id TEXT PRIMARY KEY,
+ satsdice_pay TEXT,
+ value INTEGER DEFAULT 1,
+ unique_hash TEXT UNIQUE,
+ k1 TEXT,
+ open_time INTEGER,
+ used INTEGER DEFAULT 0
+ );
+ """
+ )
+
+
+async def m003_initial(db):
+ """
+ Creates an improved satsdice table and migrates the existing data.
+ """
+ await db.execute(
+ """
+ CREATE TABLE satsdice.satsdice_payment (
+ payment_hash TEXT PRIMARY KEY,
+ satsdice_pay TEXT,
+ value INTEGER,
+ paid BOOL DEFAULT FALSE,
+ lost BOOL DEFAULT FALSE
+ );
+ """
+ )
+
+
+async def m004_make_hash_check(db):
+ """
+ Creates a hash check table.
+ """
+ await db.execute(
+ """
+ CREATE TABLE satsdice.hash_checkw (
+ id TEXT PRIMARY KEY,
+ lnurl_id TEXT
+ );
+ """
+ )
diff --git a/lnbits/extensions/satsdice/models.py b/lnbits/extensions/satsdice/models.py
new file mode 100644
index 00000000..11c8da69
--- /dev/null
+++ b/lnbits/extensions/satsdice/models.py
@@ -0,0 +1,137 @@
+import json
+from lnurl import Lnurl, LnurlWithdrawResponse, encode as lnurl_encode # type: ignore
+from urllib.parse import urlparse, urlunparse, parse_qs, urlencode, ParseResult
+from lnurl.types import LnurlPayMetadata # type: ignore
+from sqlite3 import Row
+from typing import NamedTuple, Optional, Dict
+import shortuuid # type: ignore
+from fastapi.param_functions import Query
+from pydantic.main import BaseModel
+from pydantic import BaseModel
+from typing import Optional
+from fastapi import FastAPI, Request
+
+
+class satsdiceLink(BaseModel):
+ id: str
+ wallet: str
+ title: str
+ min_bet: int
+ max_bet: int
+ amount: int
+ served_meta: int
+ served_pr: int
+ multiplier: float
+ haircut: float
+ chance: float
+ base_url: str
+ open_time: int
+
+ def lnurl(self, req: Request) -> str:
+ return lnurl_encode(req.url_for("satsdice.lnurlp_response", link_id=self.id))
+
+ @classmethod
+ def from_row(cls, row: Row) -> "satsdiceLink":
+ data = dict(row)
+ return cls(**data)
+
+ @property
+ def lnurlpay_metadata(self) -> LnurlPayMetadata:
+ return LnurlPayMetadata(
+ json.dumps(
+ [
+ [
+ "text/plain",
+ f"{self.title} (Chance: {self.chance}%, Multiplier: {self.multiplier})",
+ ]
+ ]
+ )
+ )
+
+ def success_action(self, payment_hash: str, req: Request) -> Optional[Dict]:
+ url = req.url_for(
+ "satsdice.displaywin", link_id=self.id, payment_hash=payment_hash
+ )
+ return {"tag": "url", "description": "Check the attached link", "url": url}
+
+
+class satsdicePayment(BaseModel):
+ payment_hash: str
+ satsdice_pay: str
+ value: int
+ paid: bool
+ lost: bool
+
+
+class satsdiceWithdraw(BaseModel):
+ id: str
+ satsdice_pay: str
+ value: int
+ unique_hash: str
+ k1: str
+ open_time: int
+ used: int
+
+ def lnurl(self, req: Request) -> Lnurl:
+ return lnurl_encode(
+ req.url_for("satsdice.lnurlw_response", unique_hash=self.unique_hash)
+ )
+
+ @property
+ def is_spent(self) -> bool:
+ return self.used >= 1
+
+ @property
+ def lnurl_response(self, req: Request) -> LnurlWithdrawResponse:
+ url = req.url_for("satsdice.api_lnurlw_callback", unique_hash=self.unique_hash)
+ withdrawResponse = {
+ "tag": "withdrawRequest",
+ "callback": url,
+ "k1": self.k1,
+ "minWithdrawable": self.value * 1000,
+ "maxWithdrawable": self.value * 1000,
+ "defaultDescription": "Satsdice winnings!",
+ }
+ return withdrawResponse
+
+
+class HashCheck(BaseModel):
+ id: str
+ lnurl_id: str
+
+ @classmethod
+ def from_row(cls, row: Row) -> "Hash":
+ return cls(**dict(row))
+
+
+class CreateSatsDiceLink(BaseModel):
+ wallet_id: str = Query(None)
+ title: str = Query(None)
+ base_url: str = Query(None)
+ min_bet: str = Query(None)
+ max_bet: str = Query(None)
+ multiplier: float = Query(0)
+ chance: float = Query(0)
+ haircut: int = Query(0)
+
+
+class CreateSatsDicePayment(BaseModel):
+ satsdice_pay: str = Query(None)
+ value: int = Query(0)
+ payment_hash: str = Query(None)
+
+
+class CreateSatsDiceWithdraw(BaseModel):
+ payment_hash: str = Query(None)
+ satsdice_pay: str = Query(None)
+ value: int = Query(0)
+ used: int = Query(0)
+
+
+class CreateSatsDiceWithdraws(BaseModel):
+ title: str = Query(None)
+ min_satsdiceable: int = Query(0)
+ max_satsdiceable: int = Query(0)
+ uses: int = Query(0)
+ wait_time: str = Query(None)
+ is_unique: bool = Query(False)
diff --git a/lnbits/extensions/satsdice/templates/satsdice/_api_docs.html b/lnbits/extensions/satsdice/templates/satsdice/_api_docs.html
new file mode 100644
index 00000000..7d73ae7e
--- /dev/null
+++ b/lnbits/extensions/satsdice/templates/satsdice/_api_docs.html
@@ -0,0 +1,194 @@
+
+
+
+
+
+
+
+ + Access this lnbits instance at the following url +
+
+
+
+
+
+
+
+
+
+
+
+
+Ngrok extension
++ Note that if you restart your device, your device will generate a + new url. If anyone is using your old one for wallets, lnurls, + etc., whatever they are doing will stop working. +
+ Created by + Supertestnet. +GET /satsdice/api/v1/links
+ Headers
+{"X-Api-Key": <invoice_key>}+
Body (application/json)
++ Returns 200 OK (application/json) +
+[<satsdice_link_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/links -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ GET
+ /satsdice/api/v1/links/<satsdice_id>
+ Headers
+{"X-Api-Key": <invoice_key>}+
Body (application/json)
++ Returns 201 CREATED (application/json) +
+{"lnurl": <string>}
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/links/<satsdice_id> -H
+ "X-Api-Key: {{ user.wallets[0].inkey }}"
+
+ POST /satsdice/api/v1/links
+ Headers
+{"X-Api-Key": <admin_key>}+
Body (application/json)
+{"title": <string>, "min_satsdiceable": <integer>,
+ "max_satsdiceable": <integer>, "uses": <integer>,
+ "wait_time": <integer>, "is_unique": <boolean>}
+ + Returns 201 CREATED (application/json) +
+{"lnurl": <string>}
+ Curl example
+curl -X POST {{ request.url_root }}api/v1/links -d '{"title":
+ <string>, "min_satsdiceable": <integer>,
+ "max_satsdiceable": <integer>, "uses": <integer>,
+ "wait_time": <integer>, "is_unique": <boolean>}' -H
+ "Content-type: application/json" -H "X-Api-Key: {{
+ user.wallets[0].adminkey }}"
+
+ PUT
+ /satsdice/api/v1/links/<satsdice_id>
+ Headers
+{"X-Api-Key": <admin_key>}+
Body (application/json)
+{"title": <string>, "min_satsdiceable": <integer>,
+ "max_satsdiceable": <integer>, "uses": <integer>,
+ "wait_time": <integer>, "is_unique": <boolean>}
+ + Returns 200 OK (application/json) +
+{"lnurl": <string>}
+ Curl example
+curl -X PUT {{ request.url_root }}api/v1/links/<satsdice_id> -d
+ '{"title": <string>, "min_satsdiceable": <integer>,
+ "max_satsdiceable": <integer>, "uses": <integer>,
+ "wait_time": <integer>, "is_unique": <boolean>}' -H
+ "Content-type: application/json" -H "X-Api-Key: {{
+ user.wallets[0].adminkey }}"
+
+ DELETE
+ /satsdice/api/v1/links/<satsdice_id>
+ Headers
+{"X-Api-Key": <admin_key>}+
Returns 204 NO CONTENT
+Curl example
+curl -X DELETE {{ request.url_root }}api/v1/links/<satsdice_id>
+ -H "X-Api-Key: {{ user.wallets[0].adminkey }}"
+
+ GET
+ /satsdice/api/v1/links/<the_hash>/<lnurl_id>
+ Headers
+{"X-Api-Key": <invoice_key>}+
Body (application/json)
++ Returns 201 CREATED (application/json) +
+{"status": <bool>}
+ Curl example
+curl -X GET {{ request.url_root
+ }}api/v1/links/<the_hash>/<lnurl_id> -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ GET
+ /satsdice/img/<lnurl_id>
+ Curl example
+curl -X GET {{ request.url_root }}/satsdice/img/<lnurl_id>"
+
+
+ WARNING: LNURL must be used over https or TOR
+ LNURL is a range of lightning-network standards that allow us to use
+ lightning-network differently. An LNURL satsdice is the permission for
+ someone to pull a certain amount of funds from a lightning wallet. In
+ this extension time is also added - an amount can be satsdice over a
+ period of time. A typical use case for an LNURL satsdice is a faucet,
+ although it is a very powerful technology, with much further reaching
+ implications. For example, an LNURL satsdice could be minted to pay for
+ a subscription service.
+
+ 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. +
+ Check + Awesome LNURL + for further information. +
+
+{% endblock %} {% block scripts %}
+
+{% endblock %}
diff --git a/lnbits/extensions/satsdice/templates/satsdice/displaywin.html b/lnbits/extensions/satsdice/templates/satsdice/displaywin.html
new file mode 100644
index 00000000..aa4f1375
--- /dev/null
+++ b/lnbits/extensions/satsdice/templates/satsdice/displaywin.html
@@ -0,0 +1,56 @@
+{% extends "public.html" %} {% block page %}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Copy Satsdice LNURL
+
+
+
+
+
+
+ {% include "satsdice/_lnurl.html" %}
+
+
+
++ Chance of winning: {% raw %}{{ chance }}{% endraw %}, Amount + multiplier: {{ multiplier }} +
++ Use a LNURL compatible bitcoin wallet to play the satsdice. +
+
+
+{% endblock %} {% block scripts %}
+
+{% endblock %}
diff --git a/lnbits/extensions/satsdice/templates/satsdice/error.html b/lnbits/extensions/satsdice/templates/satsdice/error.html
new file mode 100644
index 00000000..1c8fc618
--- /dev/null
+++ b/lnbits/extensions/satsdice/templates/satsdice/error.html
@@ -0,0 +1,48 @@
+{% extends "public.html" %} {% from "macros.jinja" import window_vars with
+context %}{% block page %}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Copy winnings LNURL
+
+
+
+
+
+
+ {% include "satsdice/_lnurl.html" %}
+
+
+
++ Congrats! You have won {{ value }}sats (you must claim the sats now) +
++ Use a LNURL compatible bitcoin wallet to play the satsdice. +
+
+
+{% endblock %} {% block scripts %}{{ window_vars(user) }}
+
+{% endblock %}
diff --git a/lnbits/extensions/satsdice/templates/satsdice/index.html b/lnbits/extensions/satsdice/templates/satsdice/index.html
new file mode 100644
index 00000000..a5ec243d
--- /dev/null
+++ b/lnbits/extensions/satsdice/templates/satsdice/index.html
@@ -0,0 +1,526 @@
+{% extends "base.html" %} {% from "macros.jinja" import window_vars with context
+%} {% block page %}
+
+
+
+
+ {% if lost %}
+
+
+
+
+
+
++ You lost. Play again? +
+ {% endif %} {% if paid %} ++ Winnings spent. Play again? +
+ {% endif %} ++
+
+
+
+
+
+
+ {% raw %}
+
+
+ Multipler: x{{ multiValue }}, Chance of winning: {{ chanceValueCalc
+ | percent }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+
+
+{% endblock %}
diff --git a/lnbits/extensions/satsdice/views.py b/lnbits/extensions/satsdice/views.py
new file mode 100644
index 00000000..53c1b420
--- /dev/null
+++ b/lnbits/extensions/satsdice/views.py
@@ -0,0 +1,175 @@
+from datetime import datetime
+from http import HTTPStatus
+from lnbits.decorators import check_user_exists, WalletTypeInfo, get_key_type
+from . import satsdice_ext, satsdice_renderer
+from .crud import (
+ get_satsdice_pay,
+ update_satsdice_payment,
+ get_satsdice_payment,
+ create_satsdice_withdraw,
+ get_satsdice_withdraw,
+)
+from lnbits.core.crud import (
+ get_payments,
+ get_standalone_payment,
+ delete_expired_invoices,
+ get_balance_checks,
+)
+from lnbits.core.services import check_invoice_status
+from fastapi import FastAPI, Request
+from fastapi.params import Depends
+from fastapi.templating import Jinja2Templates
+from starlette.exceptions import HTTPException
+from starlette.responses import HTMLResponse
+from lnbits.core.models import User, Payment
+from fastapi.params import Depends
+from fastapi.param_functions import Query
+import random
+from .models import CreateSatsDiceWithdraw
+
+templates = Jinja2Templates(directory="templates")
+
+
+@satsdice_ext.get("/")
+async def index(request: Request, user: User = Depends(check_user_exists)):
+ return satsdice_renderer().TemplateResponse(
+ "satsdice/index.html", {"request": request, "user": user.dict()}
+ )
+
+
+@satsdice_ext.get("/{link_id}")
+async def display(request: Request, link_id: str = Query(None)):
+ link = await get_satsdice_pay(link_id) or abort(
+ HTTPStatus.NOT_FOUND, "satsdice link does not exist."
+ )
+ return satsdice_renderer().TemplateResponse(
+ "satsdice/display.html",
+ {
+ "request": request,
+ "chance": link.chance,
+ "multiplier": link.multiplier,
+ "lnurl": link.lnurl(request),
+ "unique": True,
+ },
+ )
+
+
+@satsdice_ext.get("/win/{link_id}/{payment_hash}", name="satsdice.displaywin")
+async def displaywin(
+ request: Request, link_id: str = Query(None), payment_hash: str = Query(None)
+):
+ satsdicelink = await get_satsdice_pay(link_id) or abort(
+ HTTPStatus.NOT_FOUND, "satsdice link does not exist."
+ )
+
+ status = await check_invoice_status(
+ wallet_id=satsdicelink.wallet, payment_hash=payment_hash
+ )
+
+ withdrawLink = await get_satsdice_withdraw(payment_hash)
+ if withdrawLink:
+ return satsdice_renderer().TemplateResponse(
+ "satsdice/displaywin.html",
+ {
+ "request": request,
+ "value": withdrawLink.value,
+ "chance": satsdicelink.chance,
+ "multiplier": satsdicelink.multiplier,
+ "lnurl": withdrawLink.lnurl(request),
+ "paid": False,
+ "lost": False,
+ },
+ )
+
+ payment = await get_standalone_payment(payment_hash) or abort(
+ HTTPStatus.NOT_FOUND, "satsdice link does not exist."
+ )
+
+ if payment.pending == 1:
+ await check_invoice_status(payment.wallet_id, payment_hash)
+ payment = await get_standalone_payment(payment_hash) or abort(
+ HTTPStatus.NOT_FOUND, "satsdice link does not exist."
+ )
+ if payment.pending == 1:
+ return satsdice_renderer().TemplateResponse(
+ "satsdice/error.html",
+ {
+ "request": request,
+ "link": satsdicelink.id,
+ "paid": False,
+ "lost": True,
+ },
+ )
+
+ await update_satsdice_payment(payment_hash, paid=1)
+ paylink = await get_satsdice_payment(payment_hash)
+ if not paylink:
+
+ return satsdice_renderer().TemplateResponse(
+ "satsdice/error.html",
+ {
+ "request": request,
+ "link": satsdicelink.id,
+ "paid": False,
+ "lost": True,
+ },
+ )
+ rand1 = random.randint(0, 100)
+ rand2 = random.randint(0, 100)
+ rand3 = random.randint(0, 100)
+ rand4 = random.randint(0, 100)
+ rand = (rand1 + rand2 + rand3 + rand4) / 4
+ print(rand)
+ chance = satsdicelink.chance
+ if rand > chance:
+ await update_satsdice_payment(payment_hash, lost=1)
+ return satsdice_renderer().TemplateResponse(
+ "satsdice/error.html",
+ {
+ "request": request,
+ "link": satsdicelink.id,
+ "paid": False,
+ "lost": True,
+ },
+ )
+
+ data: CreateSatsDiceWithdraw = {
+ "satsdice_pay": satsdicelink.id,
+ "value": paylink.value * satsdicelink.multiplier,
+ "payment_hash": payment_hash,
+ "used": 0,
+ }
+
+ withdrawLink = await create_satsdice_withdraw(data)
+ return satsdice_renderer().TemplateResponse(
+ "satsdice/displaywin.html",
+ {
+ "request": request,
+ "value": withdrawLink.value,
+ "chance": satsdicelink.chance,
+ "multiplier": satsdicelink.multiplier,
+ "lnurl": withdrawLink.lnurl(request),
+ "paid": False,
+ "lost": False,
+ },
+ )
+
+
+@satsdice_ext.get("/img/{link_id}")
+async def img(link_id):
+ link = await get_satsdice_pay(link_id) or abort(
+ HTTPStatus.NOT_FOUND, "satsdice link does not exist."
+ )
+ qr = pyqrcode.create(link.lnurl)
+ stream = BytesIO()
+ qr.svg(stream, scale=3)
+ return (
+ stream.getvalue(),
+ 200,
+ {
+ "Content-Type": "image/svg+xml",
+ "Cache-Control": "no-cache, no-store, must-revalidate",
+ "Pragma": "no-cache",
+ "Expires": "0",
+ },
+ )
diff --git a/lnbits/extensions/satsdice/views_api.py b/lnbits/extensions/satsdice/views_api.py
new file mode 100644
index 00000000..315d823c
--- /dev/null
+++ b/lnbits/extensions/satsdice/views_api.py
@@ -0,0 +1,246 @@
+from http import HTTPStatus
+
+from fastapi import Request
+from fastapi.param_functions import Query
+from fastapi.params import Depends
+from lnurl.exceptions import InvalidUrl as LnurlInvalidUrl # type: ignore
+from starlette.exceptions import HTTPException
+
+from lnbits.core.crud import get_user
+from lnbits.decorators import WalletTypeInfo, get_key_type
+
+from . import satsdice_ext
+from .crud import (
+ create_satsdice_pay,
+ create_satsdice_withdraw,
+ delete_satsdice_pay,
+ delete_satsdice_withdraw,
+ get_satsdice_pay,
+ get_satsdice_pays,
+ get_satsdice_withdraw,
+ get_satsdice_withdraws,
+ update_satsdice_pay,
+ update_satsdice_withdraw,
+)
+from .models import CreateSatsDiceLink, CreateSatsDiceWithdraws
+
+################LNURL pay
+
+
+@satsdice_ext.get("/api/v1/links")
+async def api_links(
+ request: Request,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ all_wallets: str = Query(None),
+):
+ wallet_ids = [wallet.wallet.id]
+
+ if all_wallets:
+ wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids
+
+ try:
+ links = await get_satsdice_pays(wallet_ids)
+
+ return [{**link.dict(), **{"lnurl": link.lnurl(request)}} for link in links]
+ except LnurlInvalidUrl:
+ raise HTTPException(
+ status_code=HTTPStatus.UPGRADE_REQUIRED,
+ detail="LNURLs need to be delivered over a publically accessible `https` domain or Tor.",
+ )
+
+
+@satsdice_ext.get("/api/v1/links/{link_id}")
+async def api_link_retrieve(
+ data: CreateSatsDiceLink,
+ link_id: str = Query(None),
+ wallet: WalletTypeInfo = Depends(get_key_type),
+):
+ link = await get_satsdice_pay(link_id)
+
+ if not link:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Pay link does not exist."
+ )
+
+ if link.wallet != wallet.wallet.id:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN, detail="Not your pay link."
+ )
+
+ return {**link._asdict(), **{"lnurl": link.lnurl}}
+
+
+@satsdice_ext.post("/api/v1/links", status_code=HTTPStatus.CREATED)
+@satsdice_ext.put("/api/v1/links/{link_id}", status_code=HTTPStatus.OK)
+async def api_link_create_or_update(
+ data: CreateSatsDiceLink,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ link_id: str = Query(None),
+):
+ if data.min_bet > data.max_bet:
+ raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="Bad request")
+ if link_id:
+ link = await get_satsdice_pay(link_id)
+
+ if not link:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Satsdice does not exist"
+ )
+
+ if link.wallet != wallet.wallet.id:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN,
+ detail="Come on, seriously, this isn't your satsdice!",
+ )
+ data.link_id = link_id
+ link = await update_satsdice_pay(data)
+ else:
+ data.wallet_id = wallet.wallet.id
+ link = await create_satsdice_pay(data)
+
+ return {**link.dict(), **{"lnurl": link.lnurl}}
+
+
+@satsdice_ext.delete("/api/v1/links/{link_id}")
+async def api_link_delete(
+ wallet: WalletTypeInfo = Depends(get_key_type), link_id: str = Query(None)
+):
+ link = await get_satsdice_pay(link_id)
+
+ if not link:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Pay link does not exist."
+ )
+
+ if link.wallet != g.wallet.id:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN, detail="Not your pay link."
+ )
+
+ await delete_satsdice_pay(link_id)
+
+ return "", HTTPStatus.NO_CONTENT
+
+
+##########LNURL withdraw
+
+
+@satsdice_ext.get("/api/v1/withdraws")
+async def api_withdraws(
+ wallet: WalletTypeInfo = Depends(get_key_type), all_wallets: str = Query(None)
+):
+ wallet_ids = [wallet.wallet.id]
+
+ if all_wallets:
+ wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids
+ try:
+ return (
+ jsonify(
+ [
+ {**withdraw._asdict(), **{"lnurl": withdraw.lnurl}}
+ for withdraw in await get_satsdice_withdraws(wallet_ids)
+ ]
+ ),
+ HTTPStatus.OK,
+ )
+ except LnurlInvalidUrl:
+ raise HTTPException(
+ status_code=HTTPStatus.UPGRADE_REQUIRED,
+ detail="LNURLs need to be delivered over a publically accessible `https` domain or Tor.",
+ )
+
+
+@satsdice_ext.get("/api/v1/withdraws/{withdraw_id}")
+async def api_withdraw_retrieve(
+ wallet: WalletTypeInfo = Depends(get_key_type), withdraw_id: str = Query(None)
+):
+ withdraw = await get_satsdice_withdraw(withdraw_id, 0)
+
+ if not withdraw:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="satsdice withdraw does not exist."
+ )
+
+ if withdraw.wallet != wallet.wallet.id:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN, detail="Not your satsdice withdraw."
+ )
+
+ return {**withdraw._asdict(), **{"lnurl": withdraw.lnurl}}, HTTPStatus.OK
+
+
+@satsdice_ext.post("/api/v1/withdraws", status_code=HTTPStatus.CREATED)
+@satsdice_ext.put("/api/v1/withdraws/{withdraw_id}", status_code=HTTPStatus.OK)
+async def api_withdraw_create_or_update(
+ data: CreateSatsDiceWithdraws,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ withdraw_id: str = Query(None),
+):
+ if data.max_satsdiceable < data.min_satsdiceable:
+ raise HTTPException(
+ status_code=HTTPStatus.BAD_REQUEST,
+ detail="`max_satsdiceable` needs to be at least `min_satsdiceable`.",
+ )
+
+ usescsv = ""
+ for i in range(data.uses):
+ if data.is_unique:
+ usescsv += "," + str(i + 1)
+ else:
+ usescsv += "," + str(1)
+ usescsv = usescsv[1:]
+
+ if withdraw_id:
+ withdraw = await get_satsdice_withdraw(withdraw_id, 0)
+ if not withdraw:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND,
+ detail="satsdice withdraw does not exist.",
+ )
+ if withdraw.wallet != wallet.wallet.id:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN, detail="Not your satsdice withdraw."
+ )
+
+ withdraw = await update_satsdice_withdraw(
+ withdraw_id, **data, usescsv=usescsv, used=0
+ )
+ else:
+ withdraw = await create_satsdice_withdraw(
+ wallet_id=wallet.wallet.id, **data, usescsv=usescsv
+ )
+
+ return {**withdraw._asdict(), **{"lnurl": withdraw.lnurl}}
+
+
+@satsdice_ext.delete("/api/v1/withdraws/{withdraw_id}")
+async def api_withdraw_delete(
+ data: CreateSatsDiceWithdraws,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ withdraw_id: str = Query(None),
+):
+ withdraw = await get_satsdice_withdraw(withdraw_id)
+
+ if not withdraw:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="satsdice withdraw does not exist."
+ )
+
+ if withdraw.wallet != wallet.wallet.id:
+ raise HTTPException(
+ status_code=HTTPStatus.FORBIDDEN, detail="Not your satsdice withdraw."
+ )
+
+ await delete_satsdice_withdraw(withdraw_id)
+
+ return "", HTTPStatus.NO_CONTENT
+
+
+@satsdice_ext.get("/api/v1/withdraws/{the_hash}/{lnurl_id}")
+async def api_withdraw_hash_retrieve(
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ lnurl_id: str = Query(None),
+ the_hash: str = Query(None),
+):
+ hashCheck = await get_withdraw_hash_check(the_hash, lnurl_id)
+ return hashCheck
diff --git a/lnbits/extensions/satspay/README.md b/lnbits/extensions/satspay/README.md
new file mode 100644
index 00000000..d52547ae
--- /dev/null
+++ b/lnbits/extensions/satspay/README.md
@@ -0,0 +1,27 @@
+# SatsPay Server
+
+## Create onchain and LN charges. Includes webhooks!
+
+Easilly create invoices that support Lightning Network and on-chain BTC payment.
+
+1. Create a "NEW CHARGE"\
+ 
+2. Fill out the invoice fields
+ - set a descprition for the payment
+ - the amount in sats
+ - the time, in minutes, the invoice is valid for, after this period the invoice can't be payed
+ - set a webhook that will get the transaction details after a successful payment
+ - set to where the user should redirect after payment
+ - set the text for the button that will show after payment (not setting this, will display "NONE" in the button)
+ - select if you want onchain payment, LN payment or both
+ - depending on what you select you'll have to choose the respective wallets where to receive your payment\
+ 
+3. The charge will appear on the _Charges_ section\
+ 
+4. Your costumer/payee will get the payment page
+ - they can choose to pay on LN\
+ 
+ - or pay on chain\
+ 
+5. You can check the state of your charges in LNBits\
+ 
diff --git a/lnbits/extensions/satspay/__init__.py b/lnbits/extensions/satspay/__init__.py
new file mode 100644
index 00000000..b9c67e40
--- /dev/null
+++ b/lnbits/extensions/satspay/__init__.py
@@ -0,0 +1,19 @@
+import asyncio
+
+from fastapi import APIRouter
+
+from lnbits.db import Database
+from lnbits.helpers import template_renderer
+
+db = Database("ext_satspay")
+
+
+satspay_ext: APIRouter = APIRouter(prefix="/satspay", tags=["satspay"])
+
+
+def satspay_renderer():
+ return template_renderer(["lnbits/extensions/satspay/templates"])
+
+
+from .views_api import * # noqa
+from .views import * # noqa
diff --git a/lnbits/extensions/satspay/config.json b/lnbits/extensions/satspay/config.json
new file mode 100644
index 00000000..beb0071c
--- /dev/null
+++ b/lnbits/extensions/satspay/config.json
@@ -0,0 +1,8 @@
+{
+ "name": "SatsPay Server",
+ "short_description": "Create onchain and LN charges",
+ "icon": "payment",
+ "contributors": [
+ "arcbtc"
+ ]
+}
diff --git a/lnbits/extensions/satspay/crud.py b/lnbits/extensions/satspay/crud.py
new file mode 100644
index 00000000..50545d9c
--- /dev/null
+++ b/lnbits/extensions/satspay/crud.py
@@ -0,0 +1,119 @@
+from typing import List, Optional, Union
+
+# from lnbits.db import open_ext_db
+from . import db
+from .models import Charges, CreateCharge
+
+from lnbits.helpers import urlsafe_short_hash
+
+import httpx
+from lnbits.core.services import create_invoice, check_invoice_status
+from ..watchonly.crud import get_watch_wallet, get_fresh_address, get_mempool
+
+
+###############CHARGES##########################
+
+
+async def create_charge(user: str, data: CreateCharge) -> Charges:
+ charge_id = urlsafe_short_hash()
+ if data.onchainwallet:
+ wallet = await get_watch_wallet(data.onchainwallet)
+ onchain = await get_fresh_address(data.onchainwallet)
+ onchainaddress = onchain.address
+ else:
+ onchainaddress = None
+ if data.lnbitswallet:
+ payment_hash, payment_request = await create_invoice(
+ wallet_id=data.lnbitswallet, amount=data.amount, memo=charge_id
+ )
+ else:
+ payment_hash = None
+ payment_request = None
+ await db.execute(
+ """
+ INSERT INTO satspay.charges (
+ id,
+ "user",
+ description,
+ onchainwallet,
+ onchainaddress,
+ lnbitswallet,
+ payment_request,
+ payment_hash,
+ webhook,
+ completelink,
+ completelinktext,
+ time,
+ amount,
+ balance
+ )
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ """,
+ (
+ charge_id,
+ user,
+ data.description,
+ data.onchainwallet,
+ onchainaddress,
+ data.lnbitswallet,
+ payment_request,
+ payment_hash,
+ data.webhook,
+ data.completelink,
+ data.completelinktext,
+ data.time,
+ data.amount,
+ 0,
+ ),
+ )
+ return await get_charge(charge_id)
+
+
+async def update_charge(charge_id: str, **kwargs) -> Optional[Charges]:
+ q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
+ await db.execute(
+ f"UPDATE satspay.charges SET {q} WHERE id = ?", (*kwargs.values(), charge_id)
+ )
+ row = await db.fetchone("SELECT * FROM satspay.charges WHERE id = ?", (charge_id,))
+ return Charges.from_row(row) if row else None
+
+
+async def get_charge(charge_id: str) -> Charges:
+ row = await db.fetchone("SELECT * FROM satspay.charges WHERE id = ?", (charge_id,))
+ return Charges.from_row(row) if row else None
+
+
+async def get_charges(user: str) -> List[Charges]:
+ rows = await db.fetchall(
+ """SELECT * FROM satspay.charges WHERE "user" = ?""", (user,)
+ )
+ return [Charges.from_row(row) for row in rows]
+
+
+async def delete_charge(charge_id: str) -> None:
+ await db.execute("DELETE FROM satspay.charges WHERE id = ?", (charge_id,))
+
+
+async def check_address_balance(charge_id: str) -> List[Charges]:
+ charge = await get_charge(charge_id)
+ if not charge.paid:
+ if charge.onchainaddress:
+ mempool = await get_mempool(charge.user)
+ try:
+ async with httpx.AsyncClient() as client:
+ r = await client.get(
+ mempool.endpoint + "/api/address/" + charge.onchainaddress
+ )
+ respAmount = r.json()["chain_stats"]["funded_txo_sum"]
+ if respAmount >= charge.balance:
+ await update_charge(charge_id=charge_id, balance=respAmount)
+ except Exception:
+ pass
+ if charge.lnbitswallet:
+ invoice_status = await check_invoice_status(
+ charge.lnbitswallet, charge.payment_hash
+ )
+ if invoice_status.paid:
+ return await update_charge(charge_id=charge_id, balance=charge.amount)
+ row = await db.fetchone("SELECT * FROM satspay.charges WHERE id = ?", (charge_id,))
+ return Charges.from_row(row) if row else None
diff --git a/lnbits/extensions/satspay/migrations.py b/lnbits/extensions/satspay/migrations.py
new file mode 100644
index 00000000..87446c80
--- /dev/null
+++ b/lnbits/extensions/satspay/migrations.py
@@ -0,0 +1,28 @@
+async def m001_initial(db):
+ """
+ Initial wallet table.
+ """
+
+ await db.execute(
+ """
+ CREATE TABLE satspay.charges (
+ id TEXT NOT NULL PRIMARY KEY,
+ "user" TEXT,
+ description TEXT,
+ onchainwallet TEXT,
+ onchainaddress TEXT,
+ lnbitswallet TEXT,
+ payment_request TEXT,
+ payment_hash TEXT,
+ webhook TEXT,
+ completelink TEXT,
+ completelinktext TEXT,
+ time INTEGER,
+ amount INTEGER,
+ balance INTEGER DEFAULT 0,
+ timestamp TIMESTAMP NOT NULL DEFAULT """
+ + db.timestamp_now
+ + """
+ );
+ """
+ )
diff --git a/lnbits/extensions/satspay/models.py b/lnbits/extensions/satspay/models.py
new file mode 100644
index 00000000..d67e478a
--- /dev/null
+++ b/lnbits/extensions/satspay/models.py
@@ -0,0 +1,52 @@
+from sqlite3 import Row
+from typing import Optional
+from fastapi.param_functions import Query
+from pydantic import BaseModel
+import time
+
+
+class CreateCharge(BaseModel):
+ onchainwallet: str = Query(None)
+ lnbitswallet: str = Query(None)
+ description: str = Query(...)
+ webhook: str = Query(None)
+ completelink: str = Query(None)
+ completelinktext: str = Query(None)
+ time: int = Query(..., ge=1)
+ amount: int = Query(..., ge=1)
+
+
+class Charges(BaseModel):
+ id: str
+ user: str
+ description: Optional[str]
+ onchainwallet: Optional[str]
+ onchainaddress: Optional[str]
+ lnbitswallet: Optional[str]
+ payment_request: str
+ payment_hash: str
+ webhook: Optional[str]
+ completelink: Optional[str]
+ completelinktext: Optional[str] = "Back to Merchant"
+ time: int
+ amount: int
+ balance: int
+ timestamp: int
+
+ @classmethod
+ def from_row(cls, row: Row) -> "Charges":
+ return cls(**dict(row))
+
+ @property
+ def time_elapsed(self):
+ if (self.timestamp + (self.time * 60)) >= time.time():
+ return False
+ else:
+ return True
+
+ @property
+ def paid(self):
+ if self.balance >= self.amount:
+ return True
+ else:
+ return False
diff --git a/lnbits/extensions/satspay/templates/satspay/_api_docs.html b/lnbits/extensions/satspay/templates/satspay/_api_docs.html
new file mode 100644
index 00000000..af95cbf2
--- /dev/null
+++ b/lnbits/extensions/satspay/templates/satspay/_api_docs.html
@@ -0,0 +1,171 @@
+
+
+
+ New satsdice
+
+
+
+
+
+
+ {% raw %}
+
+
+ Title
+ Min bet
+ Max bet
+ Multiplier
+ Haircut
+ Chance
+
+
+
+
+
+
+
+ {{ props.row.title }}
+ {{ props.row.min_bet }}
+ {{ props.row.max_bet }}
+ *{{ props.row.multiplier }}
+ {{ props.row.haircut }}
+ {{ props.row.chance }}%
+
+
+
+
+ {% endraw %}
+
+
+
+
+
+
+
+
+
+ satsdices
+
+
+
+
+
+
+ {% include "satsdice/_api_docs.html" %}
+
+
+
+
+
+ + {{SITE_TITLE}} Sats Dice extension +
+
+
+
+
+
+
+
+
+ Update flip link
+ Create satsdice
+ Cancel
+
+
+ ID: {{ qrCodeDialog.data.id }}
+ Amount: {{ qrCodeDialog.data.amount }}
+ {{ qrCodeDialog.data.currency }} price: {{
+ fiatRates[qrCodeDialog.data.currency] ?
+ fiatRates[qrCodeDialog.data.currency] + ' sat' : 'Loading...' }}
+ Accepts comments: {{ qrCodeDialog.data.comments }}
+ Dispatches webhook to: {{ qrCodeDialog.data.webhook
+ }}
+ On success: {{ qrCodeDialog.data.success }}
+
+ Copy Satsdice LNURL
+ Copy shareable link Launch shareable link Print Satsdice Close
+
+
+ SatsPayServer, create Onchain/LN charges.
WARNING: If using with the
+ WatchOnly extension, we highly reccomend using a fresh extended public Key
+ specifically for SatsPayServer!
+
+ Created by, Ben Arc
+
POST /satspay/api/v1/charge
+ Headers
+{"X-Api-Key": <admin_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<charge_object>, ...]
+ Curl example
+curl -X POST {{ request.url_root }}api/v1/charge -d
+ '{"onchainwallet": <string, watchonly_wallet_id>,
+ "description": <string>, "webhook":<string>, "time":
+ <integer>, "amount": <integer>, "lnbitswallet":
+ <string, lnbits_wallet_id>}' -H "Content-type:
+ application/json" -H "X-Api-Key: {{user.wallets[0].adminkey }}"
+
+ PUT
+ /satspay/api/v1/charge/<charge_id>
+ Headers
+{"X-Api-Key": <admin_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<charge_object>, ...]
+ Curl example
+curl -X POST {{ request.url_root }}api/v1/charge/<charge_id>
+ -d '{"onchainwallet": <string, watchonly_wallet_id>,
+ "description": <string>, "webhook":<string>, "time":
+ <integer>, "amount": <integer>, "lnbitswallet":
+ <string, lnbits_wallet_id>}' -H "Content-type:
+ application/json" -H "X-Api-Key: {{user.wallets[0].adminkey }}"
+
+ GET
+ /satspay/api/v1/charge/<charge_id>
+ Headers
+{"X-Api-Key": <invoice_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<charge_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/charge/<charge_id>
+ -H "X-Api-Key: {{ user.wallets[0].inkey }}"
+
+ GET /satspay/api/v1/charges
+ Headers
+{"X-Api-Key": <invoice_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<charge_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/charges -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ DELETE
+ /satspay/api/v1/charge/<charge_id>
+ Headers
+{"X-Api-Key": <admin_key>}+
Returns 204 NO CONTENT
+Curl example
+curl -X DELETE {{ request.url_root
+ }}api/v1/charge/<charge_id> -H "X-Api-Key: {{
+ user.wallets[0].adminkey }}"
+
+ GET
+ /satspay/api/v1/charges/balance/<charge_id>
+ + Body (application/json) +
++ Returns 200 OK (application/json) +
+[<charge_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root
+ }}api/v1/charges/balance/<charge_id> -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock %} {% block scripts %}
+
+
+
+{% endblock %}
diff --git a/lnbits/extensions/satspay/templates/satspay/index.html b/lnbits/extensions/satspay/templates/satspay/index.html
new file mode 100644
index 00000000..d941e90b
--- /dev/null
+++ b/lnbits/extensions/satspay/templates/satspay/index.html
@@ -0,0 +1,557 @@
+{% extends "base.html" %} {% from "macros.jinja" import window_vars with context
+%} {% block page %}
+
+
+
+
+ {{ charge.description }}
+
+
+
+ Time elapsed
+
+
+ Charge paid
+
+
+
+
+
+
+
+
+
+
+
+ Charge ID: {{ charge.id }}
+
+ {% raw %} Total to pay: {{ charge_amount }}sats
+ Amount paid: {{ charge_balance }}
+ Amount due: {{ charge_amount - charge_balance }}sats {% endraw %} + +
+ + Amount paid: {{ charge_balance }}
+ Amount due: {{ charge_amount - charge_balance }}sats {% endraw %} + +
+
+
+
+
+
+
+ bitcoin onchain payment method not available
+
+
+
+ pay with lightning
+
+
+
+
+
+ bitcoin lightning payment method not available
+
+
+
+ pay onchain
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+
+
+
+{% endblock %}
diff --git a/lnbits/extensions/satspay/views.py b/lnbits/extensions/satspay/views.py
new file mode 100644
index 00000000..f6694034
--- /dev/null
+++ b/lnbits/extensions/satspay/views.py
@@ -0,0 +1,34 @@
+from fastapi.param_functions import Depends
+from starlette.exceptions import HTTPException
+from starlette.responses import HTMLResponse
+from starlette.requests import Request
+from lnbits.core.models import User
+from lnbits.core.crud import get_wallet
+from lnbits.decorators import check_user_exists
+from http import HTTPStatus
+
+from fastapi.templating import Jinja2Templates
+
+from . import satspay_ext, satspay_renderer
+from .crud import get_charge
+
+templates = Jinja2Templates(directory="templates")
+
+
+@satspay_ext.get("/", response_class=HTMLResponse)
+async def index(request: Request, user: User = Depends(check_user_exists)):
+ return satspay_renderer().TemplateResponse(
+ "satspay/index.html", {"request": request, "user": user.dict()}
+ )
+
+
+@satspay_ext.get("/{charge_id}", response_class=HTMLResponse)
+async def display(request: Request, charge_id):
+ charge = await get_charge(charge_id)
+ if not charge:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Charge link does not exist."
+ )
+ return satspay_renderer().TemplateResponse(
+ "satspay/display.html", {"request": request, "charge": charge}
+ )
diff --git a/lnbits/extensions/satspay/views_api.py b/lnbits/extensions/satspay/views_api.py
new file mode 100644
index 00000000..2ca16370
--- /dev/null
+++ b/lnbits/extensions/satspay/views_api.py
@@ -0,0 +1,144 @@
+import hashlib
+
+from http import HTTPStatus
+import httpx
+
+from fastapi import Query
+from fastapi.params import Depends
+
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import HTMLResponse, JSONResponse # type: ignore
+
+
+from lnbits.core.crud import get_user
+from lnbits.decorators import WalletTypeInfo, get_key_type
+
+from lnbits.extensions.satspay import satspay_ext
+from .models import CreateCharge
+from .crud import (
+ create_charge,
+ update_charge,
+ get_charge,
+ get_charges,
+ delete_charge,
+ check_address_balance,
+)
+
+#############################CHARGES##########################
+
+
+@satspay_ext.post("/api/v1/charge")
+@satspay_ext.put("/api/v1/charge/{charge_id}")
+async def api_charge_create_or_update(
+ data: CreateCharge, wallet: WalletTypeInfo = Depends(get_key_type), charge_id=None
+):
+ if not charge_id:
+ charge = await create_charge(user=wallet.wallet.user, data=data)
+ return charge.dict()
+ else:
+ charge = await update_charge(charge_id=charge_id, data=data)
+ return charge.dict()
+
+
+@satspay_ext.get("/api/v1/charges")
+async def api_charges_retrieve(wallet: WalletTypeInfo = Depends(get_key_type)):
+ try:
+ return [
+ {
+ **charge.dict(),
+ **{"time_elapsed": charge.time_elapsed},
+ **{"paid": charge.paid},
+ }
+ for charge in await get_charges(wallet.wallet.user)
+ ]
+ except:
+ return ""
+
+
+@satspay_ext.get("/api/v1/charge/{charge_id}")
+async def api_charge_retrieve(
+ charge_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+ charge = await get_charge(charge_id)
+
+ if not charge:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Charge does not exist."
+ )
+
+ return {
+ **charge.dict(),
+ **{"time_elapsed": charge.time_elapsed},
+ **{"paid": charge.paid},
+ }
+
+
+@satspay_ext.delete("/api/v1/charge/{charge_id}")
+async def api_charge_delete(charge_id, wallet: WalletTypeInfo = Depends(get_key_type)):
+ charge = await get_charge(charge_id)
+
+ if not charge:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Charge does not exist."
+ )
+
+ await delete_charge(charge_id)
+ raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
+
+
+#############################BALANCE##########################
+
+
+@satspay_ext.get("/api/v1/charges/balance/{charge_id}")
+async def api_charges_balance(charge_id):
+
+ charge = await check_address_balance(charge_id)
+
+ if not charge:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Charge does not exist."
+ )
+
+ if charge.paid and charge.webhook:
+ async with httpx.AsyncClient() as client:
+ try:
+ r = await client.post(
+ charge.webhook,
+ json={
+ "id": charge.id,
+ "description": charge.description,
+ "onchainaddress": charge.onchainaddress,
+ "payment_request": charge.payment_request,
+ "payment_hash": charge.payment_hash,
+ "time": charge.time,
+ "amount": charge.amount,
+ "balance": charge.balance,
+ "paid": charge.paid,
+ "timestamp": charge.timestamp,
+ "completelink": charge.completelink,
+ },
+ timeout=40,
+ )
+ except AssertionError:
+ charge.webhook = None
+ return charge.dict()
+
+
+#############################MEMPOOL##########################
+
+
+@satspay_ext.put("/api/v1/mempool")
+async def api_update_mempool(
+ endpoint: str = Query(...), wallet: WalletTypeInfo = Depends(get_key_type)
+):
+ mempool = await update_mempool(endpoint, user=wallet.wallet.user)
+ return mempool.dict()
+
+
+@satspay_ext.route("/api/v1/mempool")
+async def api_get_mempool(wallet: WalletTypeInfo = Depends(get_key_type)):
+ mempool = await get_mempool(wallet.wallet.user)
+ if not mempool:
+ mempool = await create_mempool(user=wallet.wallet.user)
+ return mempool.dict()
diff --git a/lnbits/extensions/splitpayments/README.md b/lnbits/extensions/splitpayments/README.md
new file mode 100644
index 00000000..04576a57
--- /dev/null
+++ b/lnbits/extensions/splitpayments/README.md
@@ -0,0 +1,34 @@
+# Split Payments
+
+## Have payments split between multiple wallets
+
+LNBits Split Payments extension allows for distributing payments across multiple wallets. Set it and forget it. It will keep splitting your payments across wallets forever.
+
+## Usage
+
+1. After enabling the extension, choose the source wallet that will receive and distribute the Payments
+
+
+
+2. Add the wallet or wallets info to split payments to
+
+ - get the wallet id, or an invoice key from a different wallet. It can be a completely different user as long as it's under the same LNbits instance/domain. You can get the wallet information on the API Info section on every wallet page\
+  - set a wallet _Alias_ for your own identification\
+
+- set how much, in percentage, this wallet will receive from every payment sent to the source wallets
+
+3. When done, click "SAVE TARGETS" to make the splits effective
+
+4. You can have several wallets to split to, as long as the sum of the percentages is under or equal to 100%
+
+5. When the source wallet receives a payment, the extension will automatically split the corresponding values to every wallet\
+ - on receiving a 20 sats payment\
+ 
+ - source wallet gets 18 sats\
+ 
+ - Ben's wallet (the wallet from the example) instantly, and feeless, gets the corresponding 10%, or 2 sats\
+ 
+
+## Sponsored by
+
+[](https://cryptograffiti.com/)
diff --git a/lnbits/extensions/splitpayments/__init__.py b/lnbits/extensions/splitpayments/__init__.py
new file mode 100644
index 00000000..b1e0fbdf
--- /dev/null
+++ b/lnbits/extensions/splitpayments/__init__.py
@@ -0,0 +1,38 @@
+import asyncio
+from fastapi import APIRouter, FastAPI
+from fastapi.staticfiles import StaticFiles
+from starlette.routing import Mount
+from lnbits.db import Database
+from lnbits.helpers import template_renderer
+from lnbits.tasks import catch_everything_and_restart
+
+db = Database("ext_splitpayments")
+
+splitpayments_static_files = [
+ {
+ "path": "/splitpayments/static",
+ "app": StaticFiles(directory="lnbits/extensions/splitpayments/static"),
+ "name": "splitpayments_static",
+ }
+]
+splitpayments_ext: APIRouter = APIRouter(
+ prefix="/splitpayments", tags=["splitpayments"]
+)
+
+
+def splitpayments_renderer():
+ return template_renderer(["lnbits/extensions/splitpayments/templates"])
+
+
+# from lnbits.tasks import record_async
+# splitpayments_ext.record(record_async(register_listeners))
+
+
+from .views_api import * # noqa
+from .views import * # noqa
+from .tasks import wait_for_paid_invoices
+
+
+def splitpayments_start():
+ loop = asyncio.get_event_loop()
+ loop.create_task(catch_everything_and_restart(wait_for_paid_invoices))
diff --git a/lnbits/extensions/splitpayments/config.json b/lnbits/extensions/splitpayments/config.json
new file mode 100644
index 00000000..898dcbde
--- /dev/null
+++ b/lnbits/extensions/splitpayments/config.json
@@ -0,0 +1,6 @@
+{
+ "name": "Split Payments",
+ "short_description": "Split incoming payments across wallets",
+ "icon": "call_split",
+ "contributors": ["fiatjaf", "cryptograffiti"]
+}
diff --git a/lnbits/extensions/splitpayments/crud.py b/lnbits/extensions/splitpayments/crud.py
new file mode 100644
index 00000000..ef10add4
--- /dev/null
+++ b/lnbits/extensions/splitpayments/crud.py
@@ -0,0 +1,27 @@
+from typing import List
+
+from . import db
+from .models import Target
+
+
+async def get_targets(source_wallet: str) -> List[Target]:
+ rows = await db.fetchall(
+ "SELECT * FROM splitpayments.targets WHERE source = ?", (source_wallet,)
+ )
+ return [Target(**dict(row)) for row in rows]
+
+
+async def set_targets(source_wallet: str, targets: List[Target]):
+ async with db.connect() as conn:
+ await conn.execute(
+ "DELETE FROM splitpayments.targets WHERE source = ?", (source_wallet,)
+ )
+ for target in targets:
+ await conn.execute(
+ """
+ INSERT INTO splitpayments.targets
+ (source, wallet, percent, alias)
+ VALUES (?, ?, ?, ?)
+ """,
+ (source_wallet, target.wallet, target.percent, target.alias),
+ )
diff --git a/lnbits/extensions/splitpayments/migrations.py b/lnbits/extensions/splitpayments/migrations.py
new file mode 100644
index 00000000..735afc6c
--- /dev/null
+++ b/lnbits/extensions/splitpayments/migrations.py
@@ -0,0 +1,16 @@
+async def m001_initial(db):
+ """
+ Initial split payment table.
+ """
+ await db.execute(
+ """
+ CREATE TABLE splitpayments.targets (
+ wallet TEXT NOT NULL,
+ source TEXT NOT NULL,
+ percent INTEGER NOT NULL CHECK (percent >= 0 AND percent <= 100),
+ alias TEXT,
+
+ UNIQUE (source, wallet)
+ );
+ """
+ )
diff --git a/lnbits/extensions/splitpayments/models.py b/lnbits/extensions/splitpayments/models.py
new file mode 100644
index 00000000..1c38b37d
--- /dev/null
+++ b/lnbits/extensions/splitpayments/models.py
@@ -0,0 +1,20 @@
+from typing import List, Optional
+
+from fastapi.param_functions import Query
+from pydantic import BaseModel
+
+
+class Target(BaseModel):
+ wallet: str
+ source: str
+ percent: int
+ alias: Optional[str]
+
+class TargetPutList(BaseModel):
+ wallet: str = Query(...)
+ alias: str = Query("")
+ percent: int = Query(..., ge=1)
+
+
+class TargetPut(BaseModel):
+ __root__: List[TargetPutList]
diff --git a/lnbits/extensions/splitpayments/static/js/index.js b/lnbits/extensions/splitpayments/static/js/index.js
new file mode 100644
index 00000000..dea469e5
--- /dev/null
+++ b/lnbits/extensions/splitpayments/static/js/index.js
@@ -0,0 +1,143 @@
+/* globals Quasar, Vue, _, VueQrcode, windowMixin, LNbits, LOCALE */
+
+Vue.component(VueQrcode.name, VueQrcode)
+
+function hashTargets(targets) {
+ return targets
+ .filter(isTargetComplete)
+ .map(({wallet, percent, alias}) => `${wallet}${percent}${alias}`)
+ .join('')
+}
+
+function isTargetComplete(target) {
+ return target.wallet && target.wallet.trim() !== '' && target.percent > 0
+}
+
+new Vue({
+ el: '#vue',
+ mixins: [windowMixin],
+ data() {
+ return {
+ selectedWallet: null,
+ currentHash: '', // a string that must match if the edit data is unchanged
+ targets: []
+ }
+ },
+ computed: {
+ isDirty() {
+ return hashTargets(this.targets) !== this.currentHash
+ }
+ },
+ methods: {
+ clearTargets() {
+ this.targets = [{}]
+ this.$q.notify({
+ message:
+ 'Cleared the form, but not saved. You must click to save manually.',
+ timeout: 500
+ })
+ },
+ getTargets() {
+ LNbits.api
+ .request(
+ 'GET',
+ '/splitpayments/api/v1/targets',
+ this.selectedWallet.adminkey
+ )
+ .catch(err => {
+ LNbits.utils.notifyApiError(err)
+ })
+ .then(response => {
+ this.currentHash = hashTargets(response.data)
+ this.targets = response.data.concat({})
+ })
+ },
+ changedWallet(wallet) {
+ this.selectedWallet = wallet
+ this.getTargets()
+ },
+ targetChanged(isPercent, index) {
+ // fix percent min and max range
+ if (isPercent) {
+ if (this.targets[index].percent > 100) this.targets[index].percent = 100
+ if (this.targets[index].percent < 0) this.targets[index].percent = 0
+ }
+
+ // remove empty lines (except last)
+ if (this.targets.length >= 2) {
+ for (let i = this.targets.length - 2; i >= 0; i--) {
+ let target = this.targets[i]
+ if (
+ (!target.wallet || target.wallet.trim() === '') &&
+ (!target.alias || target.alias.trim() === '') &&
+ !target.percent
+ ) {
+ this.targets.splice(i, 1)
+ }
+ }
+ }
+
+ // add a line at the end if the last one is filled
+ let last = this.targets[this.targets.length - 1]
+ if (last.wallet && last.wallet.trim() !== '' && last.percent > 0) {
+ this.targets.push({})
+ }
+
+ // sum of all percents
+ let currentTotal = this.targets.reduce(
+ (acc, target) => acc + (target.percent || 0),
+ 0
+ )
+
+ // remove last (unfilled) line if the percent is already 100
+ if (currentTotal >= 100) {
+ let last = this.targets[this.targets.length - 1]
+ if (
+ (!last.wallet || last.wallet.trim() === '') &&
+ (!last.alias || last.alias.trim() === '') &&
+ !last.percent
+ ) {
+ this.targets = this.targets.slice(0, -1)
+ }
+ }
+
+ // adjust percents of other lines (not this one)
+ if (currentTotal > 100 && isPercent) {
+ let diff = (currentTotal - 100) / (100 - this.targets[index].percent)
+ this.targets.forEach((target, t) => {
+ if (t !== index) target.percent -= Math.round(diff * target.percent)
+ })
+ }
+
+ // overwrite so changes appear
+ this.targets = this.targets
+ },
+ saveTargets() {
+ LNbits.api
+ .request(
+ 'PUT',
+ '/splitpayments/api/v1/targets',
+ this.selectedWallet.adminkey,
+ {
+ "targets": this.targets
+ .filter(isTargetComplete)
+ .map(({wallet, percent, alias}) => ({wallet, percent, alias}))
+ }
+ )
+ .then(response => {
+ this.$q.notify({
+ message: 'Split payments targets set.',
+ timeout: 700
+ })
+ this.getTargets()
+ })
+ .catch(err => {
+ LNbits.utils.notifyApiError(err)
+ })
+ }
+ },
+ created() {
+ this.selectedWallet = this.g.user.wallets[0]
+ this.getTargets()
+ }
+})
diff --git a/lnbits/extensions/splitpayments/tasks.py b/lnbits/extensions/splitpayments/tasks.py
new file mode 100644
index 00000000..12612782
--- /dev/null
+++ b/lnbits/extensions/splitpayments/tasks.py
@@ -0,0 +1,82 @@
+import json
+
+from lnbits.core.models import Payment
+from lnbits.core.crud import create_payment
+from lnbits.core import db as core_db
+from lnbits.tasks import register_invoice_listener, internal_invoice_queue
+from lnbits.helpers import urlsafe_short_hash
+
+from .crud import get_targets
+
+
+import asyncio
+import httpx
+
+from lnbits.core import db as core_db
+from lnbits.core.models import Payment
+
+
+async def wait_for_paid_invoices():
+ invoice_queue = asyncio.Queue()
+ register_invoice_listener(invoice_queue)
+
+ while True:
+ payment = await invoice_queue.get()
+ await on_invoice_paid(payment)
+
+
+async def on_invoice_paid(payment: Payment) -> None:
+ if "splitpayments" == payment.extra.get("tag") or payment.extra.get("splitted"):
+ # already splitted, ignore
+ return
+
+ # now we make some special internal transfers (from no one to the receiver)
+ targets = await get_targets(payment.wallet_id)
+ transfers = [
+ (target.wallet, int(target.percent * payment.amount / 100))
+ for target in targets
+ ]
+ transfers = [(wallet, amount) for wallet, amount in transfers if amount > 0]
+ amount_left = payment.amount - sum([amount for _, amount in transfers])
+
+ if amount_left < 0:
+ print("splitpayments failure: amount_left is negative.", payment.payment_hash)
+ return
+
+ if not targets:
+ return
+
+ # mark the original payment with one extra key, "splitted"
+ # (this prevents us from doing this process again and it's informative)
+ # and reduce it by the amount we're going to send to the producer
+ await core_db.execute(
+ """
+ UPDATE apipayments
+ SET extra = ?, amount = ?
+ WHERE hash = ?
+ AND checking_id NOT LIKE 'internal_%'
+ """,
+ (
+ json.dumps(dict(**payment.extra, splitted=True)),
+ amount_left,
+ payment.payment_hash,
+ ),
+ )
+
+ # perform the internal transfer using the same payment_hash
+ for wallet, amount in transfers:
+ internal_checking_id = f"internal_{urlsafe_short_hash()}"
+ await create_payment(
+ wallet_id=wallet,
+ checking_id=internal_checking_id,
+ payment_request="",
+ payment_hash=payment.payment_hash,
+ amount=amount,
+ memo=payment.memo,
+ pending=False,
+ extra={"tag": "splitpayments"},
+ )
+
+ # manually send this for now
+ await internal_invoice_queue.put(internal_checking_id)
+ return
diff --git a/lnbits/extensions/splitpayments/templates/splitpayments/_api_docs.html b/lnbits/extensions/splitpayments/templates/splitpayments/_api_docs.html
new file mode 100644
index 00000000..116bdd74
--- /dev/null
+++ b/lnbits/extensions/splitpayments/templates/splitpayments/_api_docs.html
@@ -0,0 +1,90 @@
+
+
+
+ {% raw %}
+ New charge
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Payment link
+
+
+
+
+ Time elapsed
+
+
+
+ PAID!
+
+
+
+ Processing
+
+
+ Delete charge
+
+
+
+
+
+
+
+ {% endraw %}
+
+
+
+
+
+
+
+
+
+
+ Charges
+
+
+
+
+ Export to CSV
+
+ {{ col.label }}
+ {{ col.value }}
+
+
+
+
+
+ {% include "satspay/_api_docs.html" %}
+
+
+
+ + {{SITE_TITLE}} satspay Extension +
+
+
+
+
+
+
+
+
+
+
+ Watch-Only extension MUST be activated and have a wallet
+
+
+
+
+
+
+
+
+
+
+
+ Create Charge
+ Cancel
+
+ + Add some wallets to the list of "Target Wallets", each with an + associated percent. After saving, every time any payment + arrives at the "Source Wallet" that payment will be split with the + target wallets according to their percent. +
+This is valid for every payment, doesn't matter how it was created.
+Target wallets can be any wallet from this same LNbits instance.
++ To remove a wallet from the targets list, just erase its fields and + save. To remove all, click "Clear" then save. +
+GET
+ /splitpayments/api/v1/targets
+ Headers
+{"X-Api-Key": <admin_key>}+
Body (application/json)
++ Returns 200 OK (application/json) +
+[{"wallet": <wallet id>, "alias": <chosen name for this
+ wallet>, "percent": <number between 1 and 100>}, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/livestream -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ PUT
+ /splitpayments/api/v1/targets
+ Headers
+{"X-Api-Key": <admin_key>}+
Body (application/json)
++ Returns 200 OK (application/json) +
+Curl example
+curl -X PUT {{ request.url_root }}api/v1/splitpayments/targets -H
+ "X-Api-Key: {{ user.wallets[0].adminkey }}" -H 'Content-Type:
+ application/json' -d '{"targets": [{"wallet": <wallet id or invoice
+ key>, "alias": <name to identify this>, "percent": <number
+ between 1 and 100>}, ...]}'
+
+
+
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+
+{% endblock %}
diff --git a/lnbits/extensions/splitpayments/views.py b/lnbits/extensions/splitpayments/views.py
new file mode 100644
index 00000000..056c7563
--- /dev/null
+++ b/lnbits/extensions/splitpayments/views.py
@@ -0,0 +1,18 @@
+from fastapi import Request
+from fastapi.params import Depends
+from fastapi.templating import Jinja2Templates
+from starlette.responses import HTMLResponse
+
+from lnbits.core.models import User
+from lnbits.decorators import check_user_exists
+
+from . import splitpayments_ext, splitpayments_renderer
+
+templates = Jinja2Templates(directory="templates")
+
+
+@splitpayments_ext.get("/", response_class=HTMLResponse)
+async def index(request: Request, user: User = Depends(check_user_exists)):
+ return splitpayments_renderer().TemplateResponse(
+ "splitpayments/index.html", {"request": request, "user": user.dict()}
+ )
diff --git a/lnbits/extensions/splitpayments/views_api.py b/lnbits/extensions/splitpayments/views_api.py
new file mode 100644
index 00000000..7b532218
--- /dev/null
+++ b/lnbits/extensions/splitpayments/views_api.py
@@ -0,0 +1,63 @@
+from http import HTTPStatus
+
+from fastapi import Request
+from fastapi.params import Depends
+from starlette.exceptions import HTTPException
+
+from lnbits.core.crud import get_wallet, get_wallet_for_key
+from lnbits.decorators import WalletTypeInfo, require_admin_key
+
+from . import splitpayments_ext
+from .crud import get_targets, set_targets
+from .models import Target, TargetPut
+
+
+@splitpayments_ext.get("/api/v1/targets")
+async def api_targets_get(wallet: WalletTypeInfo = Depends(require_admin_key)):
+ targets = await get_targets(wallet.wallet.id)
+ return [target.dict() for target in targets] or []
+
+
+@splitpayments_ext.put("/api/v1/targets")
+async def api_targets_set(
+ req: Request, wal: WalletTypeInfo = Depends(require_admin_key)
+):
+ body = await req.json()
+ targets = []
+ data = TargetPut.parse_obj(body["targets"])
+ for entry in data.__root__:
+ print("ENTRY", entry)
+ wallet = await get_wallet(entry.wallet)
+ if not wallet:
+ wallet = await get_wallet_for_key(entry.wallet, "invoice")
+ if not wallet:
+ raise HTTPException(
+ status_code=HTTPStatus.BAD_REQUEST,
+ detail=f"Invalid wallet '{entry.wallet}'.",
+ )
+
+ if wallet.id == wal.wallet.id:
+ raise HTTPException(
+ status_code=HTTPStatus.BAD_REQUEST,
+ detail="Can't split to itself.",
+ )
+
+ if entry.percent < 0:
+ raise HTTPException(
+ status_code=HTTPStatus.BAD_REQUEST,
+ detail=f"Invalid percent '{entry.percent}'.",
+ )
+
+ targets.append(
+ Target(wallet=wallet.id, source=wal.wallet.id, percent=entry.percent, alias=entry.alias)
+ )
+
+ percent_sum = sum([target.percent for target in targets])
+ if percent_sum > 100:
+ raise HTTPException(
+ status_code=HTTPStatus.BAD_REQUEST,
+ detail="Splitting over 100%.",
+ )
+
+ await set_targets(wal.wallet.id, targets)
+ return ""
diff --git a/lnbits/extensions/tpos/__init__.py b/lnbits/extensions/tpos/__init__.py
index ea7a0504..6caf88fa 100644
--- a/lnbits/extensions/tpos/__init__.py
+++ b/lnbits/extensions/tpos/__init__.py
@@ -1,25 +1,18 @@
-import asyncio
-
from fastapi import APIRouter
from lnbits.db import Database
from lnbits.helpers import template_renderer
-from lnbits.tasks import catch_everything_and_restart
db = Database("ext_tpos")
tpos_ext: APIRouter = APIRouter(
prefix="/tpos",
tags=["TPoS"]
- # "tpos", __name__, static_folder="static", template_folder="templates"
)
+
def tpos_renderer():
- return template_renderer(
- [
- "lnbits/extensions/tpos/templates",
- ]
- )
+ return template_renderer(["lnbits/extensions/tpos/templates"])
from .views_api import * # noqa
diff --git a/lnbits/extensions/tpos/crud.py b/lnbits/extensions/tpos/crud.py
index 25a65904..1a198769 100644
--- a/lnbits/extensions/tpos/crud.py
+++ b/lnbits/extensions/tpos/crud.py
@@ -3,7 +3,7 @@ from typing import List, Optional, Union
from lnbits.helpers import urlsafe_short_hash
from . import db
-from .models import TPoS, CreateTposData
+from .models import CreateTposData, TPoS
async def create_tpos(wallet_id: str, data: CreateTposData) -> TPoS:
diff --git a/lnbits/extensions/tpos/models.py b/lnbits/extensions/tpos/models.py
index a474a05d..653a055c 100644
--- a/lnbits/extensions/tpos/models.py
+++ b/lnbits/extensions/tpos/models.py
@@ -1,5 +1,5 @@
from sqlite3 import Row
-from fastapi.param_functions import Query
+
from pydantic import BaseModel
@@ -7,6 +7,7 @@ class CreateTposData(BaseModel):
name: str
currency: str
+
class TPoS(BaseModel):
id: str
wallet: str
diff --git a/lnbits/extensions/tpos/templates/tpos/tpos.html b/lnbits/extensions/tpos/templates/tpos/tpos.html
index 429c763d..d05fab4e 100644
--- a/lnbits/extensions/tpos/templates/tpos/tpos.html
+++ b/lnbits/extensions/tpos/templates/tpos/tpos.html
@@ -133,6 +133,15 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Clear
+
+
+
+
+
+ Save Targets
+
+
+
+
+
+
+
+
+
+
+
+ Target Wallets
+
+
+
+
+
+
+
+
+ {% include "splitpayments/_api_docs.html" %}
+
+
+
++ {{SITE_TITLE}} SplitPayments extension +
++ User Manager: Make and manager users/wallets +
+
+ To help developers use LNbits to manage their users, the User Manager
+ extension allows the creation and management of users and wallets.
+
For example, a games developer may be developing a game that needs
+ each user to have their own wallet, LNbits can be included in the
+ develpoers stack as the user and wallet manager.
+
+ Created by, Ben Arc
+
GET
+ /usermanager/api/v1/users
+ Body (application/json)
++ Returns 201 CREATED (application/json) +
+JSON list of users
+ Curl example
+curl -X GET {{ request.url_root }}usermanager/api/v1/users -H
+ "X-Api-Key: {{ user.wallets[0].inkey }}"
+
+ GET
+ /usermanager/api/v1/users/<user_id>
+ Body (application/json)
++ Returns 201 CREATED (application/json) +
+JSON list of users
+ Curl example
+curl -X GET {{ request.url_root
+ }}usermanager/api/v1/users/<user_id> -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ GET
+ /usermanager/api/v1/wallets/<user_id>
+ Headers
+{"X-Api-Key": <string>}
+ Body (application/json)
++ Returns 201 CREATED (application/json) +
+JSON wallet data
+ Curl example
+curl -X GET {{ request.url_root
+ }}usermanager/api/v1/wallets/<user_id> -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ GET
+ /usermanager/api/v1/wallets<wallet_id>
+ Headers
+{"X-Api-Key": <string>}
+ Body (application/json)
++ Returns 201 CREATED (application/json) +
+JSON a wallets transactions
+ Curl example
+curl -X GET {{ request.url_root
+ }}usermanager/api/v1/wallets<wallet_id> -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ POST
+ /usermanager/api/v1/users
+ Headers
+{"X-Api-Key": <string>, "Content-type":
+ "application/json"}
+ + Body (application/json) - "admin_id" is a YOUR user ID +
+{"admin_id": <string>, "user_name": <string>,
+ "wallet_name": <string>,"email": <Optional string>
+ ,"password": <Optional string>}
+ + Returns 201 CREATED (application/json) +
+{"id": <string>, "name": <string>, "admin":
+ <string>, "email": <string>, "password":
+ <string>}
+ Curl example
+curl -X POST {{ request.url_root }}usermanager/api/v1/users -d
+ '{"admin_id": "{{ user.id }}", "wallet_name": <string>,
+ "user_name": <string>, "email": <Optional string>,
+ "password": < Optional string>}' -H "X-Api-Key: {{
+ user.wallets[0].inkey }}" -H "Content-type: application/json"
+
+ POST
+ /usermanager/api/v1/wallets
+ Headers
+{"X-Api-Key": <string>, "Content-type":
+ "application/json"}
+ + Body (application/json) - "admin_id" is a YOUR user ID +
+{"user_id": <string>, "wallet_name": <string>,
+ "admin_id": <string>}
+ + Returns 201 CREATED (application/json) +
+{"id": <string>, "admin": <string>, "name":
+ <string>, "user": <string>, "adminkey": <string>,
+ "inkey": <string>}
+ Curl example
+curl -X POST {{ request.url_root }}usermanager/api/v1/wallets -d
+ '{"user_id": <string>, "wallet_name": <string>,
+ "admin_id": "{{ user.id }}"}' -H "X-Api-Key: {{ user.wallets[0].inkey
+ }}" -H "Content-type: application/json"
+
+ DELETE
+ /usermanager/api/v1/users/<user_id>
+ Headers
+{"X-Api-Key": <string>}
+ Curl example
+curl -X DELETE {{ request.url_root
+ }}usermanager/api/v1/users/<user_id> -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ DELETE
+ /usermanager/api/v1/wallets/<wallet_id>
+ Headers
+{"X-Api-Key": <string>}
+ Curl example
+curl -X DELETE {{ request.url_root
+ }}usermanager/api/v1/wallets/<wallet_id> -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ POST
+ /usermanager/api/v1/extensions
+ Headers
+{"X-Api-Key": <string>}
+ Curl example
+curl -X POST {{ request.url_root }}usermanager/api/v1/extensions -d
+ '{"userid": <string>, "extension": <string>, "active":
+ <integer>}' -H "X-Api-Key: {{ user.wallets[0].inkey }}" -H
+ "Content-type: application/json"
+
+
+
+
+
+ Create User
+ Cancel
+
+
+
+
+
+
+
+
+
+ Create Wallet
+ Cancel
+
+
+
+
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+
+{% endblock %}
diff --git a/lnbits/extensions/usermanager/views.py b/lnbits/extensions/usermanager/views.py
new file mode 100644
index 00000000..420669b0
--- /dev/null
+++ b/lnbits/extensions/usermanager/views.py
@@ -0,0 +1,15 @@
+from fastapi import Request
+from fastapi.params import Depends
+from starlette.responses import HTMLResponse
+
+from lnbits.core.models import User
+from lnbits.decorators import check_user_exists
+
+from . import usermanager_ext, usermanager_renderer
+
+
+@usermanager_ext.get("/", response_class=HTMLResponse)
+async def index(request: Request, user: User = Depends(check_user_exists)):
+ return usermanager_renderer().TemplateResponse(
+ "usermanager/index.html", {"request": request, "user": user.dict()}
+ )
diff --git a/lnbits/extensions/usermanager/views_api.py b/lnbits/extensions/usermanager/views_api.py
new file mode 100644
index 00000000..7bdee8fc
--- /dev/null
+++ b/lnbits/extensions/usermanager/views_api.py
@@ -0,0 +1,138 @@
+from http import HTTPStatus
+
+from fastapi import Query
+from fastapi.params import Depends
+from starlette.exceptions import HTTPException
+
+from lnbits.core import update_user_extension
+from lnbits.core.crud import get_user
+from lnbits.decorators import WalletTypeInfo, get_key_type
+
+from . import usermanager_ext
+from .crud import (
+ create_usermanager_user,
+ create_usermanager_wallet,
+ delete_usermanager_user,
+ delete_usermanager_wallet,
+ get_usermanager_user,
+ get_usermanager_users,
+ get_usermanager_users_wallets,
+ get_usermanager_wallet,
+ get_usermanager_wallet_transactions,
+ get_usermanager_wallets,
+)
+from .models import CreateUserData
+
+### Users
+
+
+@usermanager_ext.get("/api/v1/users", status_code=HTTPStatus.OK)
+async def api_usermanager_users(wallet: WalletTypeInfo = Depends(get_key_type)):
+ user_id = wallet.wallet.user
+ return [user.dict() for user in await get_usermanager_users(user_id)]
+
+
+@usermanager_ext.get("/api/v1/users/{user_id}", status_code=HTTPStatus.OK)
+async def api_usermanager_user(user_id, wallet: WalletTypeInfo = Depends(get_key_type)):
+ user = await get_usermanager_user(user_id)
+ return user.dict()
+
+
+@usermanager_ext.post("/api/v1/users", status_code=HTTPStatus.CREATED)
+# @api_validate_post_request(
+# schema={
+# "user_name": {"type": "string", "empty": False, "required": True},
+# "wallet_name": {"type": "string", "empty": False, "required": True},
+# "admin_id": {"type": "string", "empty": False, "required": True},
+# "email": {"type": "string", "required": False},
+# "password": {"type": "string", "required": False},
+# }
+# )
+async def api_usermanager_users_create(
+ data: CreateUserData, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+ user = await create_usermanager_user(data)
+ full = user.dict()
+ full["wallets"] = [
+ wallet.dict() for wallet in await get_usermanager_users_wallets(user.id)
+ ]
+ return full
+
+
+@usermanager_ext.delete("/api/v1/users/{user_id}")
+async def api_usermanager_users_delete(
+ user_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+ user = await get_usermanager_user(user_id)
+ if not user:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="User does not exist."
+ )
+ await delete_usermanager_user(user_id)
+ raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
+
+
+###Activate Extension
+
+
+@usermanager_ext.post("/api/v1/extensions")
+async def api_usermanager_activate_extension(
+ extension: str = Query(...), userid: str = Query(...), active: bool = Query(...)
+):
+ user = await get_user(userid)
+ if not user:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="User does not exist."
+ )
+ update_user_extension(user_id=userid, extension=extension, active=active)
+ return {"extension": "updated"}
+
+
+###Wallets
+
+
+@usermanager_ext.post("/api/v1/wallets")
+async def api_usermanager_wallets_create(
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ user_id: str = Query(...),
+ wallet_name: str = Query(...),
+ admin_id: str = Query(...),
+):
+ user = await create_usermanager_wallet(user_id, wallet_name, admin_id)
+ return user.dict()
+
+
+@usermanager_ext.get("/api/v1/wallets")
+async def api_usermanager_wallets(wallet: WalletTypeInfo = Depends(get_key_type)):
+ admin_id = wallet.wallet.user
+ return [wallet.dict() for wallet in await get_usermanager_wallets(admin_id)]
+
+
+@usermanager_ext.get("/api/v1/wallets/{wallet_id}")
+async def api_usermanager_wallet_transactions(
+ wallet_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+ return await get_usermanager_wallet_transactions(wallet_id)
+
+
+@usermanager_ext.get("/api/v1/wallets/{user_id}")
+async def api_usermanager_users_wallets(
+ user_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+ # wallet = await get_usermanager_users_wallets(user_id)
+ return [
+ s_wallet.dict() for s_wallet in await get_usermanager_users_wallets(user_id)
+ ]
+
+
+@usermanager_ext.delete("/api/v1/wallets/{wallet_id}")
+async def api_usermanager_wallets_delete(
+ wallet_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+ get_wallet = await get_usermanager_wallet(wallet_id)
+ if not get_wallet:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Wallet does not exist."
+ )
+ await delete_usermanager_wallet(wallet_id, get_wallet.user)
+ raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
diff --git a/lnbits/extensions/watchonly/README.md b/lnbits/extensions/watchonly/README.md
new file mode 100644
index 00000000..d93f7162
--- /dev/null
+++ b/lnbits/extensions/watchonly/README.md
@@ -0,0 +1,19 @@
+# Watch Only wallet
+
+## Monitor an onchain wallet and generate addresses for onchain payments
+
+Monitor an extended public key and generate deterministic fresh public keys with this simple watch only wallet. Invoice payments can also be generated, both through a publically shareable page and API.
+
+1. Start by clicking "NEW WALLET"\
+ 
+2. Fill the requested fields:
+ - give the wallet a name
+ - paste an Extended Public Key (xpub, ypub, zpub)
+ - click "CREATE WATCH-ONLY WALLET"\
+ 
+3. You can then access your onchain addresses\
+ 
+4. You can then generate bitcoin onchain adresses from LNbits\
+ 
+
+You can now use this wallet on the LNBits [SatsPayServer](https://github.com/lnbits/lnbits/blob/master/lnbits/extensions/satspay/README.md) extension
diff --git a/lnbits/extensions/watchonly/__init__.py b/lnbits/extensions/watchonly/__init__.py
new file mode 100644
index 00000000..0c525980
--- /dev/null
+++ b/lnbits/extensions/watchonly/__init__.py
@@ -0,0 +1,17 @@
+from fastapi import APIRouter
+
+from lnbits.db import Database
+from lnbits.helpers import template_renderer
+
+db = Database("ext_watchonly")
+
+
+watchonly_ext: APIRouter = APIRouter(prefix="/watchonly", tags=["watchonly"])
+
+
+def watchonly_renderer():
+ return template_renderer(["lnbits/extensions/watchonly/templates"])
+
+
+from .views import * # noqa
+from .views_api import * # noqa
diff --git a/lnbits/extensions/watchonly/config.json b/lnbits/extensions/watchonly/config.json
new file mode 100644
index 00000000..48c19ef0
--- /dev/null
+++ b/lnbits/extensions/watchonly/config.json
@@ -0,0 +1,8 @@
+{
+ "name": "Watch Only",
+ "short_description": "Onchain watch only wallets",
+ "icon": "visibility",
+ "contributors": [
+ "arcbtc"
+ ]
+}
diff --git a/lnbits/extensions/watchonly/crud.py b/lnbits/extensions/watchonly/crud.py
new file mode 100644
index 00000000..68b59da6
--- /dev/null
+++ b/lnbits/extensions/watchonly/crud.py
@@ -0,0 +1,213 @@
+from typing import List, Optional
+
+from embit.descriptor import Descriptor, Key # type: ignore
+from embit.descriptor.arguments import AllowedDerivation # type: ignore
+from embit.networks import NETWORKS # type: ignore
+
+from lnbits.helpers import urlsafe_short_hash
+
+from . import db
+from .models import Addresses, Mempool, Wallets
+
+##########################WALLETS####################
+
+
+def detect_network(k):
+ version = k.key.version
+ for network_name in NETWORKS:
+ net = NETWORKS[network_name]
+ # not found in this network
+ if version in [net["xpub"], net["ypub"], net["zpub"], net["Zpub"], net["Ypub"]]:
+ return net
+
+
+def parse_key(masterpub: str):
+ """Parses masterpub or descriptor and returns a tuple: (Descriptor, network)
+ To create addresses use descriptor.derive(num).address(network=network)
+ """
+ network = None
+ # probably a single key
+ if "(" not in masterpub:
+ k = Key.from_string(masterpub)
+ if not k.is_extended:
+ raise ValueError("The key is not a master public key")
+ if k.is_private:
+ raise ValueError("Private keys are not allowed")
+ # check depth
+ if k.key.depth != 3:
+ raise ValueError(
+ "Non-standard depth. Only bip44, bip49 and bip84 are supported with bare xpubs. For custom derivation paths use descriptors."
+ )
+ # if allowed derivation is not provided use default /{0,1}/*
+ if k.allowed_derivation is None:
+ k.allowed_derivation = AllowedDerivation.default()
+ # get version bytes
+ version = k.key.version
+ for network_name in NETWORKS:
+ net = NETWORKS[network_name]
+ # not found in this network
+ if version in [net["xpub"], net["ypub"], net["zpub"]]:
+ network = net
+ if version == net["xpub"]:
+ desc = Descriptor.from_string("pkh(%s)" % str(k))
+ elif version == net["ypub"]:
+ desc = Descriptor.from_string("sh(wpkh(%s))" % str(k))
+ elif version == net["zpub"]:
+ desc = Descriptor.from_string("wpkh(%s)" % str(k))
+ break
+ # we didn't find correct version
+ if network is None:
+ raise ValueError("Unknown master public key version")
+ else:
+ desc = Descriptor.from_string(masterpub)
+ if not desc.is_wildcard:
+ raise ValueError("Descriptor should have wildcards")
+ for k in desc.keys:
+ if k.is_extended:
+ net = detect_network(k)
+ if net is None:
+ raise ValueError(f"Unknown version: {k}")
+ if network is not None and network != net:
+ raise ValueError("Keys from different networks")
+ network = net
+ return desc, network
+
+
+async def create_watch_wallet(user: str, masterpub: str, title: str) -> Wallets:
+ # check the masterpub is fine, it will raise an exception if not
+ print("PARSE", parse_key(masterpub))
+ parse_key(masterpub)
+ wallet_id = urlsafe_short_hash()
+ await db.execute(
+ """
+ INSERT INTO watchonly.wallets (
+ id,
+ "user",
+ masterpub,
+ title,
+ address_no,
+ balance
+ )
+ VALUES (?, ?, ?, ?, ?, ?)
+ """,
+ # address_no is -1 so fresh address on empty wallet can get address with index 0
+ (wallet_id, user, masterpub, title, -1, 0),
+ )
+
+ return await get_watch_wallet(wallet_id)
+
+
+async def get_watch_wallet(wallet_id: str) -> Optional[Wallets]:
+ row = await db.fetchone(
+ "SELECT * FROM watchonly.wallets WHERE id = ?", (wallet_id,)
+ )
+ return Wallets.from_row(row) if row else None
+
+
+async def get_watch_wallets(user: str) -> List[Wallets]:
+ rows = await db.fetchall(
+ """SELECT * FROM watchonly.wallets WHERE "user" = ?""", (user,)
+ )
+ return [Wallets(**row) for row in rows]
+
+
+async def update_watch_wallet(wallet_id: str, **kwargs) -> Optional[Wallets]:
+ q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
+
+ await db.execute(
+ f"UPDATE watchonly.wallets SET {q} WHERE id = ?", (*kwargs.values(), wallet_id)
+ )
+ row = await db.fetchone(
+ "SELECT * FROM watchonly.wallets WHERE id = ?", (wallet_id,)
+ )
+ return Wallets.from_row(row) if row else None
+
+
+async def delete_watch_wallet(wallet_id: str) -> None:
+ await db.execute("DELETE FROM watchonly.wallets WHERE id = ?", (wallet_id,))
+
+ ########################ADDRESSES#######################
+
+
+async def get_derive_address(wallet_id: str, num: int):
+ wallet = await get_watch_wallet(wallet_id)
+ key = wallet.masterpub
+ desc, network = parse_key(key)
+ return desc.derive(num).address(network=network)
+
+
+async def get_fresh_address(wallet_id: str) -> Optional[Addresses]:
+ wallet = await get_watch_wallet(wallet_id)
+
+ if not wallet:
+ return None
+
+ address = await get_derive_address(wallet_id, wallet.address_no + 1)
+
+ await update_watch_wallet(wallet_id=wallet_id, address_no=wallet.address_no + 1)
+ masterpub_id = urlsafe_short_hash()
+ await db.execute(
+ """
+ INSERT INTO watchonly.addresses (
+ id,
+ address,
+ wallet,
+ amount
+ )
+ VALUES (?, ?, ?, ?)
+ """,
+ (masterpub_id, address, wallet_id, 0),
+ )
+
+ return await get_address(address)
+
+
+async def get_address(address: str) -> Optional[Addresses]:
+ row = await db.fetchone(
+ "SELECT * FROM watchonly.addresses WHERE address = ?", (address,)
+ )
+ return Addresses.from_row(row) if row else None
+
+
+async def get_addresses(wallet_id: str) -> List[Addresses]:
+ rows = await db.fetchall(
+ "SELECT * FROM watchonly.addresses WHERE wallet = ?", (wallet_id,)
+ )
+ return [Addresses(**row) for row in rows]
+
+
+######################MEMPOOL#######################
+
+
+async def create_mempool(user: str) -> Optional[Mempool]:
+ await db.execute(
+ """
+ INSERT INTO watchonly.mempool ("user",endpoint)
+ VALUES (?, ?)
+ """,
+ (user, "https://mempool.space"),
+ )
+ row = await db.fetchone(
+ """SELECT * FROM watchonly.mempool WHERE "user" = ?""", (user,)
+ )
+ return Mempool.from_row(row) if row else None
+
+
+async def update_mempool(user: str, **kwargs) -> Optional[Mempool]:
+ q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
+
+ await db.execute(
+ f"""UPDATE watchonly.mempool SET {q} WHERE "user" = ?""",
+ (*kwargs.values(), user),
+ )
+ row = await db.fetchone(
+ """SELECT * FROM watchonly.mempool WHERE "user" = ?""", (user,)
+ )
+ return Mempool.from_row(row) if row else None
+
+
+async def get_mempool(user: str) -> Mempool:
+ row = await db.fetchone(
+ """SELECT * FROM watchonly.mempool WHERE "user" = ?""", (user,)
+ )
+ return Mempool.from_row(row) if row else None
diff --git a/lnbits/extensions/watchonly/migrations.py b/lnbits/extensions/watchonly/migrations.py
new file mode 100644
index 00000000..05c229b5
--- /dev/null
+++ b/lnbits/extensions/watchonly/migrations.py
@@ -0,0 +1,36 @@
+async def m001_initial(db):
+ """
+ Initial wallet table.
+ """
+ await db.execute(
+ """
+ CREATE TABLE watchonly.wallets (
+ id TEXT NOT NULL PRIMARY KEY,
+ "user" TEXT,
+ masterpub TEXT NOT NULL,
+ title TEXT NOT NULL,
+ address_no INTEGER NOT NULL DEFAULT 0,
+ balance INTEGER NOT NULL
+ );
+ """
+ )
+
+ await db.execute(
+ """
+ CREATE TABLE watchonly.addresses (
+ id TEXT NOT NULL PRIMARY KEY,
+ address TEXT NOT NULL,
+ wallet TEXT NOT NULL,
+ amount INTEGER NOT NULL
+ );
+ """
+ )
+
+ await db.execute(
+ """
+ CREATE TABLE watchonly.mempool (
+ "user" TEXT NOT NULL,
+ endpoint TEXT NOT NULL
+ );
+ """
+ )
diff --git a/lnbits/extensions/watchonly/models.py b/lnbits/extensions/watchonly/models.py
new file mode 100644
index 00000000..d0894097
--- /dev/null
+++ b/lnbits/extensions/watchonly/models.py
@@ -0,0 +1,42 @@
+from sqlite3 import Row
+
+from fastapi.param_functions import Query
+from pydantic import BaseModel
+
+
+class CreateWallet(BaseModel):
+ masterpub: str = Query("")
+ title: str = Query("")
+
+
+class Wallets(BaseModel):
+ id: str
+ user: str
+ masterpub: str
+ title: str
+ address_no: int
+ balance: int
+
+ @classmethod
+ def from_row(cls, row: Row) -> "Wallets":
+ return cls(**dict(row))
+
+
+class Mempool(BaseModel):
+ user: str
+ endpoint: str
+
+ @classmethod
+ def from_row(cls, row: Row) -> "Mempool":
+ return cls(**dict(row))
+
+
+class Addresses(BaseModel):
+ id: str
+ address: str
+ wallet: str
+ amount: int
+
+ @classmethod
+ def from_row(cls, row: Row) -> "Addresses":
+ return cls(**dict(row))
diff --git a/lnbits/extensions/watchonly/templates/watchonly/_api_docs.html b/lnbits/extensions/watchonly/templates/watchonly/_api_docs.html
new file mode 100644
index 00000000..9d6bb6ac
--- /dev/null
+++ b/lnbits/extensions/watchonly/templates/watchonly/_api_docs.html
@@ -0,0 +1,244 @@
+
+
+
+ New User
+ New Wallet
+
+
+
+
+
+
+
+ {% raw %}
+
+
+
+ {{ col.label }}
+
+
+
+
+
+
+ {{ col.value }}
+
+
+
+
+
+ {% endraw %}
+
+
+
+
+
+
+
+ {% raw %}
+
+
+
+ {{ col.label }}
+
+
+
+
+
+
+ Link to wallet
+
+
+ {{ col.value }}
+
+
+
+
+
+ {% endraw %}
+
+
+
+
+
+
+
+
+
+ Users
+
+ Export to CSV
+
+
+
+
+
+ Wallets
+
+ Export to CSV
+
+
+
+
+
+
+ {% include "usermanager/_api_docs.html" %}
+
+
+
+
+ + {{SITE_TITLE}} User Manager Extension +
+
+ Watch Only extension uses mempool.space
+ For use with "account Extended Public Key"
+ https://iancoleman.io/bip39/
+
+
Created by,
+ Ben Arc (using,
+ Embit)
+
GET /watchonly/api/v1/wallet
+ Headers
+{"X-Api-Key": <invoice_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<wallets_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/wallet -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ GET
+ /watchonly/api/v1/wallet/<wallet_id>
+ Headers
+{"X-Api-Key": <invoice_key>}+
+ Body (application/json) +
++ Returns 201 CREATED (application/json) +
+[<wallet_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/wallet/<wallet_id>
+ -H "X-Api-Key: {{ user.wallets[0].inkey }}"
+
+ POST /watchonly/api/v1/wallet
+ Headers
+{"X-Api-Key": <admin_key>}+
+ Body (application/json) +
++ Returns 201 CREATED (application/json) +
+[<wallet_object>, ...]
+ Curl example
+curl -X POST {{ request.url_root }}api/v1/wallet -d '{"title":
+ <string>, "masterpub": <string>}' -H "Content-type:
+ application/json" -H "X-Api-Key: {{ user.wallets[0].adminkey }}"
+
+ DELETE
+ /watchonly/api/v1/wallet/<wallet_id>
+ Headers
+{"X-Api-Key": <admin_key>}+
Returns 204 NO CONTENT
+Curl example
+curl -X DELETE {{ request.url_root
+ }}api/v1/wallet/<wallet_id> -H "X-Api-Key: {{
+ user.wallets[0].adminkey }}"
+
+ GET
+ /watchonly/api/v1/addresses/<wallet_id>
+ Headers
+{"X-Api-Key": <invoice_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<address_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root
+ }}api/v1/addresses/<wallet_id> -H "X-Api-Key: {{
+ user.wallets[0].inkey }}"
+
+ GET
+ /watchonly/api/v1/address/<wallet_id>
+ Headers
+{"X-Api-Key": <invoice_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<address_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/address/<wallet_id>
+ -H "X-Api-Key: {{ user.wallets[0].inkey }}"
+
+ GET /watchonly/api/v1/mempool
+ Headers
+{"X-Api-Key": <admin_key>}+
+ Body (application/json) +
++ Returns 200 OK (application/json) +
+[<mempool_object>, ...]
+ Curl example
+curl -X GET {{ request.url_root }}api/v1/mempool -H "X-Api-Key: {{
+ user.wallets[0].adminkey }}"
+
+ POST
+ /watchonly/api/v1/mempool
+ Headers
+{"X-Api-Key": <admin_key>}+
+ Body (application/json) +
++ Returns 201 CREATED (application/json) +
+[<mempool_object>, ...]
+ Curl example
+curl -X PUT {{ request.url_root }}api/v1/mempool -d '{"endpoint":
+ <string>}' -H "Content-type: application/json" -H "X-Api-Key:
+ {{ user.wallets[0].adminkey }}"
+
+
+
+
+
+
+
+
+
+
+
+ {% raw %}
+
+
+
+
+
+ {% endraw %}
+
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+
+
+
+{% endblock %}
diff --git a/lnbits/extensions/watchonly/views.py b/lnbits/extensions/watchonly/views.py
new file mode 100644
index 00000000..e0646651
--- /dev/null
+++ b/lnbits/extensions/watchonly/views.py
@@ -0,0 +1,33 @@
+from fastapi.params import Depends
+from fastapi.templating import Jinja2Templates
+from starlette.requests import Request
+from starlette.responses import HTMLResponse
+
+from lnbits.core.models import User
+from lnbits.decorators import check_user_exists
+
+from . import watchonly_ext, watchonly_renderer
+
+# from .crud import get_payment
+
+
+templates = Jinja2Templates(directory="templates")
+
+
+@watchonly_ext.get("/", response_class=HTMLResponse)
+async def index(request: Request, user: User = Depends(check_user_exists)):
+ return watchonly_renderer().TemplateResponse(
+ "watchonly/index.html", {"request": request, "user": user.dict()}
+ )
+
+
+# @watchonly_ext.get("/{charge_id}", response_class=HTMLResponse)
+# async def display(request: Request, charge_id):
+# link = get_payment(charge_id)
+# if not link:
+# raise HTTPException(
+# status_code=HTTPStatus.NOT_FOUND,
+# detail="Charge link does not exist."
+# )
+#
+# return watchonly_renderer().TemplateResponse("watchonly/display.html", {"request": request,"link": link.dict()})
diff --git a/lnbits/extensions/watchonly/views_api.py b/lnbits/extensions/watchonly/views_api.py
new file mode 100644
index 00000000..61978b74
--- /dev/null
+++ b/lnbits/extensions/watchonly/views_api.py
@@ -0,0 +1,119 @@
+from http import HTTPStatus
+
+from fastapi import Query
+from fastapi.params import Depends
+from starlette.exceptions import HTTPException
+
+from lnbits.core.crud import get_user
+from lnbits.decorators import WalletTypeInfo, get_key_type
+from lnbits.extensions.watchonly import watchonly_ext
+
+from .crud import (create_mempool, create_watch_wallet, delete_watch_wallet,
+ get_addresses, get_fresh_address, get_mempool,
+ get_watch_wallet, get_watch_wallets, update_mempool)
+from .models import CreateWallet
+
+###################WALLETS#############################
+
+
+@watchonly_ext.get("/api/v1/wallet")
+async def api_wallets_retrieve(wallet: WalletTypeInfo = Depends(get_key_type)):
+
+ try:
+ return [wallet.dict() for wallet in await get_watch_wallets(wallet.wallet.user)]
+ except:
+ return ""
+
+
+@watchonly_ext.get("/api/v1/wallet/{wallet_id}")
+async def api_wallet_retrieve(
+ wallet_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+ w_wallet = await get_watch_wallet(wallet_id)
+
+ if not w_wallet:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Wallet does not exist."
+ )
+
+ return w_wallet.dict()
+
+
+@watchonly_ext.post("/api/v1/wallet")
+async def api_wallet_create_or_update(
+ data: CreateWallet, wallet_id=None, w: WalletTypeInfo = Depends(get_key_type)
+):
+ try:
+ wallet = await create_watch_wallet(
+ user=w.wallet.user, masterpub=data.masterpub, title=data.title
+ )
+ except Exception as e:
+ raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail=str(e))
+
+ mempool = await get_mempool(w.wallet.user)
+ if not mempool:
+ create_mempool(user=w.wallet.user)
+ return wallet.dict()
+
+
+@watchonly_ext.delete("/api/v1/wallet/{wallet_id}")
+async def api_wallet_delete(wallet_id, w: WalletTypeInfo = Depends(get_key_type)):
+ wallet = await get_watch_wallet(wallet_id)
+
+ if not wallet:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Wallet does not exist."
+ )
+
+ await delete_watch_wallet(wallet_id)
+
+ raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
+
+
+#############################ADDRESSES##########################
+
+
+@watchonly_ext.get("/api/v1/address/{wallet_id}")
+async def api_fresh_address(wallet_id, w: WalletTypeInfo = Depends(get_key_type)):
+ await get_fresh_address(wallet_id)
+
+ addresses = await get_addresses(wallet_id)
+
+ return [address.dict() for address in addresses]
+
+
+@watchonly_ext.get("/api/v1/addresses/{wallet_id}")
+async def api_get_addresses(wallet_id, w: WalletTypeInfo = Depends(get_key_type)):
+ wallet = await get_watch_wallet(wallet_id)
+
+ if not wallet:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="Wallet does not exist."
+ )
+
+ addresses = await get_addresses(wallet_id)
+
+ if not addresses:
+ await get_fresh_address(wallet_id)
+ addresses = await get_addresses(wallet_id)
+
+ return [address.dict() for address in addresses]
+
+
+#############################MEMPOOL##########################
+
+
+@watchonly_ext.put("/api/v1/mempool")
+async def api_update_mempool(
+ endpoint: str = Query(...), w: WalletTypeInfo = Depends(get_key_type)
+):
+ mempool = await update_mempool(endpoint, user=w.wallet.user)
+ return mempool.dict()
+
+
+@watchonly_ext.get("/api/v1/mempool")
+async def api_get_mempool(w: WalletTypeInfo = Depends(get_key_type)):
+ mempool = await get_mempool(w.wallet.user)
+ if not mempool:
+ mempool = await create_mempool(user=w.wallet.user)
+ return mempool.dict()
diff --git a/lnbits/extensions/withdraw/__init__.py b/lnbits/extensions/withdraw/__init__.py
index 184b4f01..b756aeea 100644
--- a/lnbits/extensions/withdraw/__init__.py
+++ b/lnbits/extensions/withdraw/__init__.py
@@ -21,18 +21,14 @@ withdraw_ext: APIRouter = APIRouter(
# "withdraw", __name__, static_folder="static", template_folder="templates"
)
+
def withdraw_renderer():
- return template_renderer(
- [
- "lnbits/extensions/withdraw/templates",
- ]
- )
+ return template_renderer(["lnbits/extensions/withdraw/templates"])
-from .views_api import * # noqa
-from .views import * # noqa
from .lnurl import * # noqa
-
+from .views import * # noqa
+from .views_api import * # noqa
# @withdraw_ext.on_event("startup")
# def _do_it():
diff --git a/lnbits/extensions/withdraw/crud.py b/lnbits/extensions/withdraw/crud.py
index 183d8629..01a841cf 100644
--- a/lnbits/extensions/withdraw/crud.py
+++ b/lnbits/extensions/withdraw/crud.py
@@ -1,15 +1,14 @@
from datetime import datetime
from typing import List, Optional, Union
+
from lnbits.helpers import urlsafe_short_hash
from . import db
-from .models import WithdrawLink, HashCheck, CreateWithdrawData
+from .models import CreateWithdrawData, HashCheck, WithdrawLink
async def create_withdraw_link(
- data: CreateWithdrawData,
- wallet_id: str,
- usescsv: str,
+ data: CreateWithdrawData, wallet_id: str, usescsv: str
) -> WithdrawLink:
link_id = urlsafe_short_hash()
await db.execute(
@@ -61,7 +60,7 @@ async def get_withdraw_link(link_id: str, num=0) -> Optional[WithdrawLink]:
# for item in row:
# link.append(item)
# link.append(num)
- print("GET_LINK", WithdrawLink.from_row(row))
+ # print("GET_LINK", WithdrawLink.from_row(row))
return WithdrawLink.from_row(row)
@@ -115,10 +114,7 @@ def chunks(lst, n):
yield lst[i : i + n]
-async def create_hash_check(
- the_hash: str,
- lnurl_id: str,
-) -> HashCheck:
+async def create_hash_check(the_hash: str, lnurl_id: str) -> HashCheck:
await db.execute(
"""
INSERT INTO withdraw.hash_check (
@@ -127,10 +123,7 @@ async def create_hash_check(
)
VALUES (?, ?)
""",
- (
- the_hash,
- lnurl_id,
- ),
+ (the_hash, lnurl_id),
)
hashCheck = await get_hash_check(the_hash, lnurl_id)
return hashCheck
diff --git a/lnbits/extensions/withdraw/lnurl.py b/lnbits/extensions/withdraw/lnurl.py
index 75339cf7..af3ecff4 100644
--- a/lnbits/extensions/withdraw/lnurl.py
+++ b/lnbits/extensions/withdraw/lnurl.py
@@ -1,25 +1,30 @@
-import shortuuid # type: ignore
-from http import HTTPStatus
from datetime import datetime
+from http import HTTPStatus
+
+import shortuuid # type: ignore
+from fastapi import HTTPException
+from fastapi.param_functions import Query
+from starlette.requests import Request
from lnbits.core.services import pay_invoice
-from starlette.requests import Request
from . import withdraw_ext
from .crud import get_withdraw_link_by_hash, update_withdraw_link
-
# FOR LNURLs WHICH ARE NOT UNIQUE
-@withdraw_ext.get("/api/v1/lnurl/{unique_hash}", status_code=HTTPStatus.OK, name="withdraw.api_lnurl_response")
+@withdraw_ext.get(
+ "/api/v1/lnurl/{unique_hash}",
+ status_code=HTTPStatus.OK,
+ name="withdraw.api_lnurl_response",
+)
async def api_lnurl_response(request: Request, unique_hash):
link = await get_withdraw_link_by_hash(unique_hash)
if not link:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail="Withdraw link does not exist."
+ status_code=HTTPStatus.NOT_FOUND, detail="Withdraw link does not exist."
)
# return ({"status": "ERROR", "reason": "LNURL-withdraw not found."},
# HTTPStatus.OK,
@@ -37,66 +42,22 @@ async def api_lnurl_response(request: Request, unique_hash):
return link.lnurl_response(request).dict()
-# FOR LNURLs WHICH ARE UNIQUE
-
-
-@withdraw_ext.get("/api/v1/lnurl/{unique_hash}/{id_unique_hash}", status_code=HTTPStatus.OK, name="withdraw.api_lnurl_multi_response")
-async def api_lnurl_multi_response(request: Request, unique_hash, id_unique_hash):
- link = await get_withdraw_link_by_hash(unique_hash)
-
- if not link:
- raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail="LNURL-withdraw not found."
- )
- # return (
- # {"status": "ERROR", "reason": "LNURL-withdraw not found."},
- # HTTPStatus.OK,
- # )
-
- if link.is_spent:
- raise HTTPException(
- # WHAT STATUS_CODE TO USE??
- detail="Withdraw is spent."
- )
- # return (
- # {"status": "ERROR", "reason": "Withdraw is spent."},
- # HTTPStatus.OK,
- # )
-
- useslist = link.usescsv.split(",")
- found = False
- for x in useslist:
- tohash = link.id + link.unique_hash + str(x)
- if id_unique_hash == shortuuid.uuid(name=tohash):
- found = True
- if not found:
- raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail="LNURL-withdraw not found."
- )
- # return (
- # {"status": "ERROR", "reason": "LNURL-withdraw not found."},
- # HTTPStatus.OK,
- # )
-
- return link.lnurl_response(request).dict()
-
-
# CALLBACK
-@withdraw_ext.get("/api/v1/lnurl/cb/{unique_hash}", status_code=HTTPStatus.OK, name="withdraw.api_lnurl_callback")
-async def api_lnurl_callback(unique_hash):
+@withdraw_ext.get("/api/v1/lnurl/cb/{unique_hash}", name="withdraw.api_lnurl_callback")
+async def api_lnurl_callback(
+ request: Request,
+ unique_hash: str = Query(...),
+ k1: str = Query(...),
+ payment_request: str = Query(..., alias="pr"),
+):
link = await get_withdraw_link_by_hash(unique_hash)
- k1 = request.query_params['k1']
- payment_request = request.query_params['pr']
now = int(datetime.now().timestamp())
if not link:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail="LNURL-withdraw not found."
+ status_code=HTTPStatus.NOT_FOUND, detail="LNURL-withdraw not found."
)
# return (
# {"status": "ERROR", "reason": "LNURL-withdraw not found."},
@@ -114,10 +75,7 @@ async def api_lnurl_callback(unique_hash):
# )
if link.k1 != k1:
- raise HTTPException(
- status_code=HTTPStatus.BAD_REQUEST,
- detail="Bad request."
- )
+ raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="Bad request.")
# return {"status": "ERROR", "reason": "Bad request."}, HTTPStatus.OK
if now < link.open_time:
@@ -163,3 +121,51 @@ async def api_lnurl_callback(unique_hash):
return {"status": "ERROR", "reason": str(e)}
return {"status": "OK"}
+
+
+# FOR LNURLs WHICH ARE UNIQUE
+
+
+@withdraw_ext.get(
+ "/api/v1/lnurl/{unique_hash}/{id_unique_hash}",
+ status_code=HTTPStatus.OK,
+ name="withdraw.api_lnurl_multi_response",
+)
+async def api_lnurl_multi_response(request: Request, unique_hash, id_unique_hash):
+ link = await get_withdraw_link_by_hash(unique_hash)
+
+ if not link:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="LNURL-withdraw not found."
+ )
+ # return (
+ # {"status": "ERROR", "reason": "LNURL-withdraw not found."},
+ # HTTPStatus.OK,
+ # )
+
+ if link.is_spent:
+ raise HTTPException(
+ # WHAT STATUS_CODE TO USE??
+ detail="Withdraw is spent."
+ )
+ # return (
+ # {"status": "ERROR", "reason": "Withdraw is spent."},
+ # HTTPStatus.OK,
+ # )
+
+ useslist = link.usescsv.split(",")
+ found = False
+ for x in useslist:
+ tohash = link.id + link.unique_hash + str(x)
+ if id_unique_hash == shortuuid.uuid(name=tohash):
+ found = True
+ if not found:
+ raise HTTPException(
+ status_code=HTTPStatus.NOT_FOUND, detail="LNURL-withdraw not found."
+ )
+ # return (
+ # {"status": "ERROR", "reason": "LNURL-withdraw not found."},
+ # HTTPStatus.OK,
+ # )
+
+ return link.lnurl_response(request).dict()
diff --git a/lnbits/extensions/withdraw/models.py b/lnbits/extensions/withdraw/models.py
index 55b234e3..8de38e38 100644
--- a/lnbits/extensions/withdraw/models.py
+++ b/lnbits/extensions/withdraw/models.py
@@ -1,17 +1,20 @@
-from starlette.requests import Request
-from fastapi.param_functions import Query
-from lnurl import Lnurl, LnurlWithdrawResponse, encode as lnurl_encode # type: ignore
from sqlite3 import Row
-from pydantic import BaseModel
+
import shortuuid # type: ignore
+from fastapi.param_functions import Query
+from lnurl import Lnurl, LnurlWithdrawResponse
+from lnurl import encode as lnurl_encode # type: ignore
+from pydantic import BaseModel
+from starlette.requests import Request
+
class CreateWithdrawData(BaseModel):
- title: str = Query(...)
- min_withdrawable: int = Query(..., ge=1)
- max_withdrawable: int = Query(..., ge=1)
- uses: int = Query(..., ge=1)
- wait_time: int = Query(..., ge=1)
- is_unique: bool
+ title: str = Query(...)
+ min_withdrawable: int = Query(..., ge=1)
+ max_withdrawable: int = Query(..., ge=1)
+ uses: int = Query(..., ge=1)
+ wait_time: int = Query(..., ge=1)
+ is_unique: bool
class WithdrawLink(BaseModel):
@@ -49,20 +52,18 @@ class WithdrawLink(BaseModel):
url = req.url_for(
"withdraw.api_lnurl_multi_response",
unique_hash=self.unique_hash,
- id_unique_hash=multihash
+ id_unique_hash=multihash,
)
else:
url = req.url_for(
- "withdraw.api_lnurl_response",
- unique_hash=self.unique_hash
+ "withdraw.api_lnurl_response", unique_hash=self.unique_hash
)
return lnurl_encode(url)
-
def lnurl_response(self, req: Request) -> LnurlWithdrawResponse:
url = req.url_for(
- "withdraw.api_lnurl_callback", unique_hash=self.unique_hash, _external=True
+ name="withdraw.api_lnurl_callback", unique_hash=self.unique_hash
)
return LnurlWithdrawResponse(
callback=url,
diff --git a/lnbits/extensions/withdraw/templates/withdraw/display.html b/lnbits/extensions/withdraw/templates/withdraw/display.html
index f4d6ef9d..245b3ed1 100644
--- a/lnbits/extensions/withdraw/templates/withdraw/display.html
+++ b/lnbits/extensions/withdraw/templates/withdraw/display.html
@@ -7,10 +7,10 @@
{% if link.is_spent %}
+
+
+ {% raw %}
+ New wallet
+
+
+
+
+
+
+
+
+
+
+
+
+ {{ col.label }}
+
+
+
+
+
+
+
+ Adresses
+
+
+
+ {{ col.value }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{ col.label }}
+
+
+
+
+
+
+ {{ col.name == 'value' ? satBtc(col.value) : col.value }}
+
+
+
+
+
+
+
+
+ {% endraw %}
+
+
+ Point to another Mempool
+ {{ this.mempool.endpoint }}
+
+
+
+ set
+ cancel
+
+
+
+
+
+
+
+ Wallets
+
+
+
+
+
+
+
+ {{utxos.sats ? ' sats' : ' BTC'}}
+
+ {{satBtc(utxos.total)}}
+
+
+
+
+ Transactions
+
+
+
+
+
+
+
+
+
+
+ {% include "watchonly/_api_docs.html" %}
+
+
+
+
+ + {{SITE_TITLE}} Watch Only Extension +
+
+ Create Watch-only Wallet
+ Cancel
+
+ Addresses
++
+ Current:
+ {{ currentaddress }}
+
+
+ Get fresh address
+ Close
+
+
- Copy LNURL
diff --git a/lnbits/extensions/withdraw/views.py b/lnbits/extensions/withdraw/views.py
index 9bdaee45..6329ce64 100644
--- a/lnbits/extensions/withdraw/views.py
+++ b/lnbits/extensions/withdraw/views.py
@@ -1,25 +1,29 @@
from http import HTTPStatus
-import pyqrcode
from io import BytesIO
+
+import pyqrcode
+from fastapi import Request
+from fastapi.params import Depends
+from fastapi.templating import Jinja2Templates
+from starlette.exceptions import HTTPException
+from starlette.responses import HTMLResponse, StreamingResponse
+
+from lnbits.core.models import User
from lnbits.decorators import check_user_exists
from . import withdraw_ext, withdraw_renderer
-from .crud import get_withdraw_link, chunks
-from fastapi import FastAPI, Request
-from fastapi.params import Depends
-from fastapi.templating import Jinja2Templates
-
-from starlette.exceptions import HTTPException
-from starlette.responses import HTMLResponse
-from lnbits.core.models import User
+from .crud import chunks, get_withdraw_link
templates = Jinja2Templates(directory="templates")
+
@withdraw_ext.get("/", response_class=HTMLResponse)
# @validate_uuids(["usr"], required=True)
# @check_user_exists()
async def index(request: Request, user: User = Depends(check_user_exists)):
- return withdraw_renderer().TemplateResponse("withdraw/index.html", {"request":request,"user": user.dict()})
+ return withdraw_renderer().TemplateResponse(
+ "withdraw/index.html", {"request": request, "user": user.dict()}
+ )
@withdraw_ext.get("/{link_id}", response_class=HTMLResponse)
@@ -28,21 +32,28 @@ async def display(request: Request, link_id):
if not link:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail="Withdraw link does not exist."
+ status_code=HTTPStatus.NOT_FOUND, detail="Withdraw link does not exist."
)
# response.status_code = HTTPStatus.NOT_FOUND
# return "Withdraw link does not exist." #probably here is where we should return the 404??
- return withdraw_renderer().TemplateResponse("withdraw/display.html", {"request":request,"link":{**link.dict(), "lnurl": link.lnurl(request)}, "unique":True})
+ print("LINK", link)
+ return withdraw_renderer().TemplateResponse(
+ "withdraw/display.html",
+ {
+ "request": request,
+ "link": link.dict(),
+ "lnurl": link.lnurl(req=request),
+ "unique": True,
+ },
+ )
-@withdraw_ext.get("/img/{link_id}", response_class=HTMLResponse)
+@withdraw_ext.get("/img/{link_id}", response_class=StreamingResponse)
async def img(request: Request, link_id):
link = await get_withdraw_link(link_id, 0)
if not link:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail="Withdraw link does not exist."
+ status_code=HTTPStatus.NOT_FOUND, detail="Withdraw link does not exist."
)
# response.status_code = HTTPStatus.NOT_FOUND
# return "Withdraw link does not exist."
@@ -50,10 +61,14 @@ async def img(request: Request, link_id):
print(qr)
stream = BytesIO()
qr.svg(stream, scale=3)
- return (
- stream.getvalue(),
- 200,
- {
+ stream.seek(0)
+
+ async def _generator(stream: BytesIO):
+ yield stream.getvalue()
+
+ return StreamingResponse(
+ _generator(stream),
+ headers={
"Content-Type": "image/svg+xml",
"Cache-Control": "no-cache, no-store, must-revalidate",
"Pragma": "no-cache",
@@ -67,15 +82,17 @@ async def print_qr(request: Request, link_id):
link = await get_withdraw_link(link_id)
if not link:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail="Withdraw link does not exist."
+ status_code=HTTPStatus.NOT_FOUND, detail="Withdraw link does not exist."
)
# response.status_code = HTTPStatus.NOT_FOUND
# return "Withdraw link does not exist."
if link.uses == 0:
- return withdraw_renderer().TemplateResponse("withdraw/print_qr.html", {"request":request,"link":link.dict(), unique:False})
+ return withdraw_renderer().TemplateResponse(
+ "withdraw/print_qr.html",
+ {"request": request, "link": link.dict(), unique: False},
+ )
links = []
count = 0
@@ -83,8 +100,7 @@ async def print_qr(request: Request, link_id):
linkk = await get_withdraw_link(link_id, count)
if not linkk:
raise HTTPException(
- status_code=HTTPStatus.NOT_FOUND,
- detail="Withdraw link does not exist."
+ status_code=HTTPStatus.NOT_FOUND, detail="Withdraw link does not exist."
)
# response.status_code = HTTPStatus.NOT_FOUND
# return "Withdraw link does not exist."
@@ -93,4 +109,6 @@ async def print_qr(request: Request, link_id):
page_link = list(chunks(links, 2))
linked = list(chunks(page_link, 5))
print("LINKED", linked)
- return withdraw_renderer().TemplateResponse("withdraw/print_qr.html", {"request":request,"link":linked, "unique":True})
+ return withdraw_renderer().TemplateResponse(
+ "withdraw/print_qr.html", {"request": request, "link": linked, "unique": True}
+ )
diff --git a/lnbits/extensions/withdraw/views_api.py b/lnbits/extensions/withdraw/views_api.py
index 93b498ef..678346f9 100644
--- a/lnbits/extensions/withdraw/views_api.py
+++ b/lnbits/extensions/withdraw/views_api.py
@@ -1,34 +1,31 @@
-from fastapi.params import Depends
-from fastapi.param_functions import Query
-from pydantic.main import BaseModel
-
from http import HTTPStatus
+
+from fastapi.param_functions import Query
+from fastapi.params import Depends
from lnurl.exceptions import InvalidUrl as LnurlInvalidUrl # type: ignore
from starlette.exceptions import HTTPException
from starlette.requests import Request
-from starlette.responses import HTMLResponse, JSONResponse # type: ignore
from lnbits.core.crud import get_user
from lnbits.decorators import WalletTypeInfo, get_key_type
+
+from . import withdraw_ext
+from .crud import (create_withdraw_link,
+ delete_withdraw_link, get_hash_check, get_withdraw_link,
+ get_withdraw_links, update_withdraw_link)
from .models import CreateWithdrawData
# from fastapi import FastAPI, Query, Response
-from . import withdraw_ext
-from .crud import (
- create_withdraw_link,
- get_withdraw_link,
- get_withdraw_links,
- update_withdraw_link,
- delete_withdraw_link,
- create_hash_check,
- get_hash_check,
-)
@withdraw_ext.get("/api/v1/links", status_code=HTTPStatus.OK)
# @api_check_wallet_key("invoice")
-async def api_links(req: Request, wallet: WalletTypeInfo = Depends(get_key_type), all_wallets: bool = Query(False)):
+async def api_links(
+ req: Request,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+ all_wallets: bool = Query(False),
+):
wallet_ids = [wallet.wallet.id]
if all_wallets:
@@ -36,12 +33,9 @@ async def api_links(req: Request, wallet: WalletTypeInfo = Depends(get_key_type)
try:
return [
- {
- **link.dict(),
- **{"lnurl": link.lnurl(req)},
- }
- for link in await get_withdraw_links(wallet_ids)
- ]
+ {**link.dict(), **{"lnurl": link.lnurl(req)}}
+ for link in await get_withdraw_links(wallet_ids)
+ ]
except LnurlInvalidUrl:
raise HTTPException(
@@ -59,21 +53,20 @@ async def api_link_retrieve(link_id, wallet: WalletTypeInfo = Depends(get_key_ty
if not link:
raise HTTPException(
- detail="Withdraw link does not exist.",
- status_code=HTTPStatus.NOT_FOUND
+ detail="Withdraw link does not exist.", status_code=HTTPStatus.NOT_FOUND
)
# response.status_code = HTTPStatus.NOT_FOUND
# return {"message": "Withdraw link does not exist."}
if link.wallet != wallet.wallet.id:
raise HTTPException(
- detail="Not your withdraw link.",
- status_code=HTTPStatus.FORBIDDEN
+ detail="Not your withdraw link.", status_code=HTTPStatus.FORBIDDEN
)
# response.status_code = HTTPStatus.FORBIDDEN
# return {"message": "Not your withdraw link."}
return {**link, **{"lnurl": link.lnurl(request)}}
+
# class CreateData(BaseModel):
# title: str = Query(...)
# min_withdrawable: int = Query(..., ge=1)
@@ -82,14 +75,20 @@ async def api_link_retrieve(link_id, wallet: WalletTypeInfo = Depends(get_key_ty
# wait_time: int = Query(..., ge=1)
# is_unique: bool
+
@withdraw_ext.post("/api/v1/links", status_code=HTTPStatus.CREATED)
@withdraw_ext.put("/api/v1/links/{link_id}", status_code=HTTPStatus.OK)
# @api_check_wallet_key("admin")
-async def api_link_create_or_update(req: Request, data: CreateWithdrawData, link_id: str = None, wallet: WalletTypeInfo = Depends(get_key_type)):
+async def api_link_create_or_update(
+ req: Request,
+ data: CreateWithdrawData,
+ link_id: str = None,
+ wallet: WalletTypeInfo = Depends(get_key_type),
+):
if data.max_withdrawable < data.min_withdrawable:
raise HTTPException(
detail="`max_withdrawable` needs to be at least `min_withdrawable`.",
- status_code=HTTPStatus.BAD_REQUEST
+ status_code=HTTPStatus.BAD_REQUEST,
)
# response.status_code = HTTPStatus.BAD_REQUEST
# return {
@@ -108,15 +107,13 @@ async def api_link_create_or_update(req: Request, data: CreateWithdrawData, link
link = await get_withdraw_link(link_id, 0)
if not link:
raise HTTPException(
- detail="Withdraw link does not exist.",
- status_code=HTTPStatus.NOT_FOUND
+ detail="Withdraw link does not exist.", status_code=HTTPStatus.NOT_FOUND
)
# response.status_code = HTTPStatus.NOT_FOUND
# return {"message": "Withdraw link does not exist."}
if link.wallet != wallet.wallet.id:
raise HTTPException(
- detail="Not your withdraw link.",
- status_code=HTTPStatus.FORBIDDEN
+ detail="Not your withdraw link.", status_code=HTTPStatus.FORBIDDEN
)
# response.status_code = HTTPStatus.FORBIDDEN
# return {"message": "Not your withdraw link."}
@@ -137,16 +134,14 @@ async def api_link_delete(link_id, wallet: WalletTypeInfo = Depends(get_key_type
if not link:
raise HTTPException(
- detail="Withdraw link does not exist.",
- status_code=HTTPStatus.NOT_FOUND
+ detail="Withdraw link does not exist.", status_code=HTTPStatus.NOT_FOUND
)
# response.status_code = HTTPStatus.NOT_FOUND
# return {"message": "Withdraw link does not exist."}
if link.wallet != wallet.wallet.id:
raise HTTPException(
- detail="Not your withdraw link.",
- status_code=HTTPStatus.FORBIDDEN
+ detail="Not your withdraw link.", status_code=HTTPStatus.FORBIDDEN
)
# response.status_code = HTTPStatus.FORBIDDEN
# return {"message": "Not your withdraw link."}
@@ -158,6 +153,8 @@ async def api_link_delete(link_id, wallet: WalletTypeInfo = Depends(get_key_type
@withdraw_ext.get("/api/v1/links/{the_hash}/{lnurl_id}", status_code=HTTPStatus.OK)
# @api_check_wallet_key("invoice")
-async def api_hash_retrieve(the_hash, lnurl_id, wallet: WalletTypeInfo = Depends(get_key_type)):
+async def api_hash_retrieve(
+ the_hash, lnurl_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
hashCheck = await get_hash_check(the_hash, lnurl_id)
return hashCheck
diff --git a/lnbits/helpers.py b/lnbits/helpers.py
index dbb060a5..a1396411 100644
--- a/lnbits/helpers.py
+++ b/lnbits/helpers.py
@@ -41,7 +41,9 @@ class ExtensionManager:
]:
try:
with open(
- os.path.join(settings.LNBITS_PATH, "extensions", extension, "config.json")
+ os.path.join(
+ settings.LNBITS_PATH, "extensions", extension, "config.json"
+ )
) as json_file:
config = json.load(json_file)
is_valid = True
@@ -137,11 +139,8 @@ def get_vendored(ext: str, prefer_minified: bool = False) -> List[str]:
def url_for_vendored(abspath: str) -> str:
return "/" + os.path.relpath(abspath, settings.LNBITS_PATH)
-def url_for(
- endpoint: str,
- external: Optional[bool] = False,
- **params: Any,
-) -> str:
+
+def url_for(endpoint: str, external: Optional[bool] = False, **params: Any) -> str:
base = g().base_url if external else ""
url_params = "?"
for key in params:
@@ -149,9 +148,12 @@ def url_for(
url = f"{base}{endpoint}{url_params}"
return url
+
def template_renderer(additional_folders: List = []) -> Jinja2Templates:
t = Jinja2Templates(
- loader=jinja2.FileSystemLoader(["lnbits/templates", "lnbits/core/templates", *additional_folders]),
+ loader=jinja2.FileSystemLoader(
+ ["lnbits/templates", "lnbits/core/templates", *additional_folders]
+ )
)
t.env.globals["SITE_TITLE"] = settings.LNBITS_SITE_TITLE
t.env.globals["SITE_TAGLINE"] = settings.LNBITS_SITE_TAGLINE
@@ -159,7 +161,7 @@ def template_renderer(additional_folders: List = []) -> Jinja2Templates:
t.env.globals["LNBITS_THEME_OPTIONS"] = settings.LNBITS_THEME_OPTIONS
t.env.globals["LNBITS_VERSION"] = settings.LNBITS_COMMIT
t.env.globals["EXTENSIONS"] = get_valid_extensions()
-
+
if settings.DEBUG:
t.env.globals["VENDORED_JS"] = map(url_for_vendored, get_js_vendored())
t.env.globals["VENDORED_CSS"] = map(url_for_vendored, get_css_vendored())
diff --git a/lnbits/jinja2_templating.py b/lnbits/jinja2_templating.py
index 5e3ceba2..f74f05c0 100644
--- a/lnbits/jinja2_templating.py
+++ b/lnbits/jinja2_templating.py
@@ -1,4 +1,4 @@
-# Borrowed from the excellent accent-starlette
+# Borrowed from the excellent accent-starlette
# https://github.com/accent-starlette/starlette-core/blob/master/starlette_core/templating.py
import typing
@@ -23,7 +23,7 @@ class Jinja2Templates(templating.Jinja2Templates):
def get_environment(self, loader: "jinja2.BaseLoader") -> "jinja2.Environment":
@jinja2.contextfunction
def url_for(context: dict, name: str, **path_params: typing.Any) -> str:
- request: Request = context["request"] # type: starlette.requests.Request
+ request: Request = context["request"] # type: starlette.requests.Request
return request.app.url_path_for(name, **path_params)
def url_params_update(init: QueryParams, **new: typing.Any) -> QueryParams:
diff --git a/lnbits/requestvars.py b/lnbits/requestvars.py
index 7dcf9203..2f7139d8 100644
--- a/lnbits/requestvars.py
+++ b/lnbits/requestvars.py
@@ -1,8 +1,9 @@
import contextvars
import types
-request_global = contextvars.ContextVar("request_global",
- default=types.SimpleNamespace())
+request_global = contextvars.ContextVar(
+ "request_global", default=types.SimpleNamespace()
+)
def g() -> types.SimpleNamespace:
diff --git a/lnbits/settings.py b/lnbits/settings.py
index a351b5f1..475f5f47 100644
--- a/lnbits/settings.py
+++ b/lnbits/settings.py
@@ -52,8 +52,7 @@ SERVICE_FEE = env.float("LNBITS_SERVICE_FEE", default=0.0)
try:
LNBITS_COMMIT = (
subprocess.check_output(
- ["git", "-C", LNBITS_PATH, "rev-parse", "HEAD"],
- stderr=subprocess.DEVNULL,
+ ["git", "-C", LNBITS_PATH, "rev-parse", "HEAD"], stderr=subprocess.DEVNULL
)
.strip()
.decode("ascii")
diff --git a/lnbits/static/js/base.js b/lnbits/static/js/base.js
index fec75796..13f68388 100644
--- a/lnbits/static/js/base.js
+++ b/lnbits/static/js/base.js
@@ -225,7 +225,7 @@ window.LNbits = {
Quasar.plugins.Notify.create({
timeout: 5000,
type: types[error.response.status] || 'warning',
- message: error.response.data.message || null,
+ message: error.response.data.message || error.response.data.detail || null,
caption:
[error.response.status, ' ', error.response.statusText]
.join('')
diff --git a/lnbits/wallets/clightning.py b/lnbits/wallets/clightning.py
index 0780776f..c1b10220 100644
--- a/lnbits/wallets/clightning.py
+++ b/lnbits/wallets/clightning.py
@@ -35,7 +35,7 @@ class CLightningWallet(Wallet):
try:
answer = self.ln.help("invoicewithdescriptionhash")
if answer["help"][0]["command"].startswith(
- "invoicewithdescriptionhash msatoshi label description_hash",
+ "invoicewithdescriptionhash msatoshi label description_hash"
):
self.supports_description_hash = True
except:
@@ -53,8 +53,7 @@ class CLightningWallet(Wallet):
try:
funds = self.ln.listfunds()
return StatusResponse(
- None,
- sum([ch["channel_sat"] * 1000 for ch in funds["channels"]]),
+ None, sum([ch["channel_sat"] * 1000 for ch in funds["channels"]])
)
except RpcError as exc:
error_message = f"lightningd '{exc.method}' failed with '{exc.error}'."
@@ -121,11 +120,7 @@ class CLightningWallet(Wallet):
i = 0
while True:
call = json.dumps(
- {
- "method": "waitanyinvoice",
- "id": 0,
- "params": [self.last_pay_index],
- }
+ {"method": "waitanyinvoice", "id": 0, "params": [self.last_pay_index]}
)
await stream.send_all(call.encode("utf-8"))
diff --git a/lnbits/wallets/lnbits.py b/lnbits/wallets/lnbits.py
index b262cb1e..638fb7c1 100644
--- a/lnbits/wallets/lnbits.py
+++ b/lnbits/wallets/lnbits.py
@@ -30,9 +30,7 @@ class LNbitsWallet(Wallet):
async with httpx.AsyncClient() as client:
try:
r = await client.get(
- url=f"{self.endpoint}/api/v1/wallet",
- headers=self.key,
- timeout=15,
+ url=f"{self.endpoint}/api/v1/wallet", headers=self.key, timeout=15
)
except Exception as exc:
return StatusResponse(
@@ -65,9 +63,7 @@ class LNbitsWallet(Wallet):
async with httpx.AsyncClient() as client:
r = await client.post(
- url=f"{self.endpoint}/api/v1/payments",
- headers=self.key,
- json=data,
+ url=f"{self.endpoint}/api/v1/payments", headers=self.key, json=data
)
ok, checking_id, payment_request, error_message = (
not r.is_error,
diff --git a/lnbits/wallets/lndgrpc.py b/lnbits/wallets/lndgrpc.py
index 99ff3637..89cbded7 100644
--- a/lnbits/wallets/lndgrpc.py
+++ b/lnbits/wallets/lndgrpc.py
@@ -64,19 +64,11 @@ def load_macaroon(macaroon_path: str):
def parse_checking_id(checking_id: str) -> bytes:
- return base64.b64decode(
- checking_id.replace("_", "/"),
- )
+ return base64.b64decode(checking_id.replace("_", "/"))
def stringify_checking_id(r_hash: bytes) -> str:
- return (
- base64.b64encode(
- r_hash,
- )
- .decode("utf-8")
- .replace("/", "_")
- )
+ return base64.b64encode(r_hash).decode("utf-8").replace("/", "_")
class LndWallet(Wallet):
@@ -177,28 +169,23 @@ class LndWallet(Wallet):
async def paid_invoices_stream(self) -> AsyncGenerator[str, None]:
async with purerpc.secure_channel(
- self.endpoint,
- self.port,
- get_ssl_context(self.cert_path),
+ self.endpoint, self.port, get_ssl_context(self.cert_path)
) as channel:
client = purerpc.Client("lnrpc.Lightning", channel)
subscribe_invoices = client.get_method_stub(
"SubscribeInvoices",
purerpc.RPCSignature(
- purerpc.Cardinality.UNARY_STREAM,
- ln.InvoiceSubscription,
- ln.Invoice,
+ purerpc.Cardinality.UNARY_STREAM, ln.InvoiceSubscription, ln.Invoice
),
)
- if self.macaroon_path.split('.')[-1] == 'macaroon':
+ if self.macaroon_path.split(".")[-1] == "macaroon":
macaroon = load_macaroon(self.macaroon_path)
else:
macaroon = self.macaroon_path
async for inv in subscribe_invoices(
- ln.InvoiceSubscription(),
- metadata=[("macaroon", macaroon)],
+ ln.InvoiceSubscription(), metadata=[("macaroon", macaroon)]
):
if not inv.settled:
continue
diff --git a/lnbits/wallets/lndrest.py b/lnbits/wallets/lndrest.py
index 4b31c726..f0824dac 100644
--- a/lnbits/wallets/lndrest.py
+++ b/lnbits/wallets/lndrest.py
@@ -39,8 +39,7 @@ class LndRestWallet(Wallet):
try:
async with httpx.AsyncClient(verify=self.cert) as client:
r = await client.get(
- f"{self.endpoint}/v1/balance/channels",
- headers=self.auth,
+ f"{self.endpoint}/v1/balance/channels", headers=self.auth
)
except (httpx.ConnectError, httpx.RequestError):
return StatusResponse(f"Unable to connect to {self.endpoint}.", 0)
@@ -60,10 +59,7 @@ class LndRestWallet(Wallet):
memo: Optional[str] = None,
description_hash: Optional[bytes] = None,
) -> InvoiceResponse:
- data: Dict = {
- "value": amount,
- "private": True,
- }
+ data: Dict = {"value": amount, "private": True}
if description_hash:
data["description_hash"] = base64.b64encode(description_hash).decode(
"ascii"
@@ -73,9 +69,7 @@ class LndRestWallet(Wallet):
async with httpx.AsyncClient(verify=self.cert) as client:
r = await client.post(
- url=f"{self.endpoint}/v1/invoices",
- headers=self.auth,
- json=data,
+ url=f"{self.endpoint}/v1/invoices", headers=self.auth, json=data
)
if r.is_error:
@@ -117,8 +111,7 @@ class LndRestWallet(Wallet):
async with httpx.AsyncClient(verify=self.cert) as client:
r = await client.get(
- url=f"{self.endpoint}/v1/invoice/{checking_id}",
- headers=self.auth,
+ url=f"{self.endpoint}/v1/invoice/{checking_id}", headers=self.auth
)
if r.is_error or not r.json().get("settled"):
@@ -164,9 +157,7 @@ class LndRestWallet(Wallet):
while True:
try:
async with httpx.AsyncClient(
- timeout=None,
- headers=self.auth,
- verify=self.cert,
+ timeout=None, headers=self.auth, verify=self.cert
) as client:
async with client.stream("GET", url) as r:
async for line in r.aiter_lines():
diff --git a/lnbits/wallets/lnpay.py b/lnbits/wallets/lnpay.py
index ab8e0d81..98610a79 100644
--- a/lnbits/wallets/lnpay.py
+++ b/lnbits/wallets/lnpay.py
@@ -139,12 +139,10 @@ class LNPayWallet(Wallet):
lntx_id = data["data"]["wtx"]["lnTx"]["id"]
async with httpx.AsyncClient() as client:
r = await client.get(
- f"{self.endpoint}/lntx/{lntx_id}?fields=settled",
- headers=self.auth,
+ f"{self.endpoint}/lntx/{lntx_id}?fields=settled", headers=self.auth
)
data = r.json()
if data["settled"]:
await self.queue.put(lntx_id)
raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
-
diff --git a/lnbits/wallets/lntxbot.py b/lnbits/wallets/lntxbot.py
index c804542a..190336a3 100644
--- a/lnbits/wallets/lntxbot.py
+++ b/lnbits/wallets/lntxbot.py
@@ -30,9 +30,7 @@ class LntxbotWallet(Wallet):
async def status(self) -> StatusResponse:
async with httpx.AsyncClient() as client:
r = await client.get(
- f"{self.endpoint}/balance",
- headers=self.auth,
- timeout=40,
+ f"{self.endpoint}/balance", headers=self.auth, timeout=40
)
try:
data = r.json()
@@ -60,10 +58,7 @@ class LntxbotWallet(Wallet):
async with httpx.AsyncClient() as client:
r = await client.post(
- f"{self.endpoint}/addinvoice",
- headers=self.auth,
- json=data,
- timeout=40,
+ f"{self.endpoint}/addinvoice", headers=self.auth, json=data, timeout=40
)
if r.is_error:
@@ -123,8 +118,7 @@ class LntxbotWallet(Wallet):
async def get_payment_status(self, checking_id: str) -> PaymentStatus:
async with httpx.AsyncClient() as client:
r = await client.post(
- url=f"{self.endpoint}/paymentstatus/{checking_id}",
- headers=self.auth,
+ url=f"{self.endpoint}/paymentstatus/{checking_id}", headers=self.auth
)
data = r.json()
diff --git a/lnbits/wallets/opennode.py b/lnbits/wallets/opennode.py
index ddc2849e..965b6d66 100644
--- a/lnbits/wallets/opennode.py
+++ b/lnbits/wallets/opennode.py
@@ -36,9 +36,7 @@ class OpenNodeWallet(Wallet):
try:
async with httpx.AsyncClient() as client:
r = await client.get(
- f"{self.endpoint}/v1/account/balance",
- headers=self.auth,
- timeout=40,
+ f"{self.endpoint}/v1/account/balance", headers=self.auth, timeout=40
)
except (httpx.ConnectError, httpx.RequestError):
return StatusResponse(f"Unable to connect to '{self.endpoint}'", 0)
@@ -137,7 +135,6 @@ class OpenNodeWallet(Wallet):
if "status" not in data or data["status"] != "paid":
raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
-
charge_id = data["id"]
x = hmac.new(self.auth["Authorization"].encode("ascii"), digestmod="sha256")
x.update(charge_id.encode("ascii"))
@@ -147,4 +144,3 @@ class OpenNodeWallet(Wallet):
await self.queue.put(charge_id)
raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
-
diff --git a/lnbits/wallets/spark.py b/lnbits/wallets/spark.py
index ca8f6efe..a97ad310 100644
--- a/lnbits/wallets/spark.py
+++ b/lnbits/wallets/spark.py
@@ -75,8 +75,7 @@ class SparkWallet(Wallet):
return StatusResponse(str(e), 0)
return StatusResponse(
- None,
- sum([ch["channel_sat"] * 1000 for ch in funds["channels"]]),
+ None, sum([ch["channel_sat"] * 1000 for ch in funds["channels"]])
)
async def create_invoice(