Wallet: Lightning interface (#318)

* mint does not start yet

* fix import

* revert mint db migrations

* handle zero fee case

* cli: adjust fee message

* wallet: replace requests with httpx

* clean up

* rename http client decorator

* fix pending check in main, todo: TEST PROXIES WITH HTTPX

* fix up

* use httpx for nostr as well

* update packages to same versions as https://github.com/lnbits/lnbits/pull/1609/files

* fix proof deserialization

* check for string

* tests passing

* adjust wallet api tests

* lockfile

* add correct responses to Lightning interface and delete melt_id for proofs for which the payent has failed

* fix create_invoice checking_id response

* migrations atomic

* proofs are stored automatically when created

* make format

* use bolt11 lib

* stricter type checking

* add fee response to payments

* assert fees in test_melt

* test that mint_id and melt_id is stored correctly in proofs and proofs_used

* remove traces

* refactor: Lightning interface into own file and LedgerCrud with typing

* fix tests

* fix payment response

* rename variable

cashu/mint/crud.py

@@ -8,44 +8,155 @@ class LedgerCrud:
     """
     Database interface for Cashu mint.
 
-    This class needs to be overloaded by any app that imports the Cashu mint.
+    This class needs to be overloaded by any app that imports the Cashu mint and wants
+    to use their own database.
     """
 
-    async def get_keyset(*args, **kwags):
-        return await get_keyset(*args, **kwags)  # type: ignore
+    async def get_keyset(
+        self,
+        db: Database,
+        id: str = "",
+        derivation_path: str = "",
+        conn: Optional[Connection] = None,
+    ):
+        return await get_keyset(
+            db=db,
+            id=id,
+            derivation_path=derivation_path,
+            conn=conn,
+        )
 
-    async def get_lightning_invoice(*args, **kwags):
-        return await get_lightning_invoice(*args, **kwags)  # type: ignore
+    async def get_lightning_invoice(
+        self,
+        db: Database,
+        id: str,
+        conn: Optional[Connection] = None,
+    ):
+        return await get_lightning_invoice(
+            db=db,
+            id=id,
+            conn=conn,
+        )
 
-    async def get_secrets_used(*args, **kwags):
-        return await get_secrets_used(*args, **kwags)  # type: ignore
+    async def get_secrets_used(
+        self,
+        db: Database,
+        conn: Optional[Connection] = None,
+    ):
+        return await get_secrets_used(db=db, conn=conn)
 
-    async def invalidate_proof(*args, **kwags):
-        return await invalidate_proof(*args, **kwags)  # type: ignore
+    async def invalidate_proof(
+        self,
+        db: Database,
+        proof: Proof,
+        conn: Optional[Connection] = None,
+    ):
+        return await invalidate_proof(
+            db=db,
+            proof=proof,
+            conn=conn,
+        )
 
-    async def get_proofs_pending(*args, **kwags):
-        return await get_proofs_pending(*args, **kwags)  # type: ignore
+    async def get_proofs_pending(
+        self,
+        db: Database,
+        conn: Optional[Connection] = None,
+    ):
+        return await get_proofs_pending(db=db, conn=conn)
 
-    async def set_proof_pending(*args, **kwags):
-        return await set_proof_pending(*args, **kwags)  # type: ignore
+    async def set_proof_pending(
+        self,
+        db: Database,
+        proof: Proof,
+        conn: Optional[Connection] = None,
+    ):
+        return await set_proof_pending(
+            db=db,
+            proof=proof,
+            conn=conn,
+        )
 
-    async def unset_proof_pending(*args, **kwags):
-        return await unset_proof_pending(*args, **kwags)  # type: ignore
+    async def unset_proof_pending(
+        self, proof: Proof, db: Database, conn: Optional[Connection] = None
+    ):
+        return await unset_proof_pending(
+            proof=proof,
+            db=db,
+            conn=conn,
+        )
 
-    async def store_keyset(*args, **kwags):
-        return await store_keyset(*args, **kwags)  # type: ignore
+    async def store_keyset(
+        self,
+        db: Database,
+        keyset: MintKeyset,
+        conn: Optional[Connection] = None,
+    ):
+        return await store_keyset(
+            db=db,
+            keyset=keyset,
+            conn=conn,
+        )
 
-    async def store_lightning_invoice(*args, **kwags):
-        return await store_lightning_invoice(*args, **kwags)  # type: ignore
+    async def store_lightning_invoice(
+        self,
+        db: Database,
+        invoice: Invoice,
+        conn: Optional[Connection] = None,
+    ):
+        return await store_lightning_invoice(
+            db=db,
+            invoice=invoice,
+            conn=conn,
+        )
 
-    async def store_promise(*args, **kwags):
-        return await store_promise(*args, **kwags)  # type: ignore
+    async def store_promise(
+        self,
+        *,
+        db: Database,
+        amount: int,
+        B_: str,
+        C_: str,
+        id: str,
+        e: str = "",
+        s: str = "",
+        conn: Optional[Connection] = None,
+    ):
+        return await store_promise(
+            db=db,
+            amount=amount,
+            B_=B_,
+            C_=C_,
+            id=id,
+            e=e,
+            s=s,
+            conn=conn,
+        )
 
-    async def get_promise(*args, **kwags):
-        return await get_promise(*args, **kwags)  # type: ignore
+    async def get_promise(
+        self,
+        db: Database,
+        B_: str,
+        conn: Optional[Connection] = None,
+    ):
+        return await get_promise(
+            db=db,
+            B_=B_,
+            conn=conn,
+        )
 
-    async def update_lightning_invoice(*args, **kwags):
-        return await update_lightning_invoice(*args, **kwags)  # type: ignore
+    async def update_lightning_invoice(
+        self,
+        db: Database,
+        id: str,
+        issued: bool,
+        conn: Optional[Connection] = None,
+    ):
+        return await update_lightning_invoice(
+            db=db,
+            id=id,
+            issued=issued,
+            conn=conn,
+        )
 
 
 async def store_promise(
@@ -174,46 +285,47 @@ async def store_lightning_invoice(
     await (conn or db).execute(
         f"""
         INSERT INTO {table_with_schema(db, 'invoices')}
-          (amount, pr, hash, issued, payment_hash)
-        VALUES (?, ?, ?, ?, ?)
+          (amount, bolt11, id, issued, payment_hash, out)
+        VALUES (?, ?, ?, ?, ?, ?)
         """,
         (
             invoice.amount,
-            invoice.pr,
-            invoice.hash,
+            invoice.bolt11,
+            invoice.id,
             invoice.issued,
             invoice.payment_hash,
+            invoice.out,
         ),
     )
 
 
 async def get_lightning_invoice(
     db: Database,
-    hash: str,
+    id: str,
     conn: Optional[Connection] = None,
 ):
     row = await (conn or db).fetchone(
         f"""
         SELECT * from {table_with_schema(db, 'invoices')}
-        WHERE hash = ?
+        WHERE id = ?
         """,
-        (hash,),
+        (id,),
     )
-
-    return Invoice(**row) if row else None
+    row_dict = dict(row)
+    return Invoice(**row_dict) if row_dict else None
 
 
 async def update_lightning_invoice(
     db: Database,
-    hash: str,
+    id: str,
     issued: bool,
     conn: Optional[Connection] = None,
 ):
     await (conn or db).execute(
-        f"UPDATE {table_with_schema(db, 'invoices')} SET issued = ? WHERE hash = ?",
+        f"UPDATE {table_with_schema(db, 'invoices')} SET issued = ? WHERE id = ?",
         (
             issued,
-            hash,
+            id,
         ),
     )