postgres support.

lnbits/extensions/watchonly/crud.py

@@ -1,16 +1,13 @@
-from typing import List, Optional, Union
+from typing import List, Optional
 
-# from lnbits.db import open_ext_db
 from . import db
 from .models import Wallets, Addresses, Mempool
 
 from lnbits.helpers import urlsafe_short_hash
 
-from embit.descriptor import Descriptor, Key
-from embit.descriptor.arguments import AllowedDerivation
-from embit.networks import NETWORKS
-
-import httpx
+from embit.descriptor import Descriptor, Key  # type: ignore
+from embit.descriptor.arguments import AllowedDerivation  # type: ignore
+from embit.networks import NETWORKS  # type: ignore
 
 
 ##########################WALLETS####################
@@ -83,9 +80,9 @@ async def create_watch_wallet(*, user: str, masterpub: str, title: str) -> Walle
     wallet_id = urlsafe_short_hash()
     await db.execute(
         """
-        INSERT INTO wallets (
+        INSERT INTO watchonly.wallets (
             id,
-            user,
+            "user",
             masterpub,
             title,
             address_no,
@@ -101,13 +98,17 @@ async def create_watch_wallet(*, user: str, masterpub: str, title: str) -> Walle
     return await get_watch_wallet(wallet_id)
 
 
-async def get_watch_wallet(wallet_id: str) -> Wallets:
-    row = await db.fetchone("SELECT * FROM wallets WHERE id = ?", (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 wallets WHERE user = ?", (user,))
+    rows = await db.fetchall(
+        """SELECT * FROM watchonly.wallets WHERE "user" = ?""", (user,)
+    )
     return [Wallets(**row) for row in rows]
 
 
@@ -115,28 +116,31 @@ 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 wallets SET {q} WHERE id = ?", (*kwargs.values(), wallet_id)
+        f"UPDATE watchonly.wallets SET {q} WHERE id = ?", (*kwargs.values(), wallet_id)
+    )
+    row = await db.fetchone(
+        "SELECT * FROM watchonly.wallets WHERE id = ?", (wallet_id,)
     )
-    row = await db.fetchone("SELECT * FROM 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 wallets WHERE id = ?", (wallet_id,))
+    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[2]
     desc, network = parse_key(key)
     return desc.derive(num).address(network=network)
 
 
-async def get_fresh_address(wallet_id: str) -> Addresses:
+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[4] + 1)
 
@@ -144,7 +148,7 @@ async def get_fresh_address(wallet_id: str) -> Addresses:
     masterpub_id = urlsafe_short_hash()
     await db.execute(
         """
-        INSERT INTO addresses (
+        INSERT INTO watchonly.addresses (
             id,
             address,
             wallet,
@@ -158,42 +162,52 @@ async def get_fresh_address(wallet_id: str) -> Addresses:
     return await get_address(address)
 
 
-async def get_address(address: str) -> Addresses:
-    row = await db.fetchone("SELECT * FROM addresses WHERE 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 addresses WHERE wallet = ?", (wallet_id,))
+    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) -> Mempool:
+async def create_mempool(user: str) -> Optional[Mempool]:
     await db.execute(
         """
-        INSERT INTO mempool (
-            user, 
-            endpoint
-        ) 
+        INSERT INTO watchonly.mempool ("user",endpoint) 
         VALUES (?, ?)
         """,
         (user, "https://mempool.space"),
     )
-    row = await db.fetchone("SELECT * FROM mempool WHERE user = ?", (user,))
+    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 mempool SET {q} WHERE user = ?", (*kwargs.values(), user))
-    row = await db.fetchone("SELECT * FROM mempool WHERE user = ?", (user,))
+    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 mempool WHERE user = ?", (user,))
+    row = await db.fetchone(
+        """SELECT * FROM watchonly.mempool WHERE "user" = ?""", (user,)
+    )
     return Mempool.from_row(row) if row else None