allow for internal and external migrations

lnbits/extensions/cashu/__init__.py

@@ -13,7 +13,8 @@ import sys
 
 sys.path.append("/Users/cc/git/cashu")
 from cashu.mint.ledger import Ledger
-from .crud import LedgerCrud
+
+# from .crud import LedgerCrud
 
 # db = Database("ext_cashu", LNBITS_DATA_FOLDER)
 
@@ -22,7 +23,6 @@ ledger = Ledger(
     # seed=MINT_PRIVATE_KEY,
     seed="asd",
     derivation_path="0/0/0/1",
-    crud=LedgerCrud,
 )
 
 cashu_ext: APIRouter = APIRouter(prefix="/api/v1/cashu", tags=["cashu"])

lnbits/extensions/cashu/config.json

@@ -3,7 +3,5 @@
   "short_description": "Ecash mint and wallet",
   "icon": "approval",
   "contributors": ["arcbtc", "calle", "vlad"],
-  "hidden": false,
+  "hidden": false
-  "migration_module": "cashu.mint.migrations",
-  "db_name": "cashu"
 }

lnbits/extensions/cashu/crud.py

@@ -11,6 +11,7 @@ from loguru import logger
 from lnbits.helpers import urlsafe_short_hash
 
 from . import db
+
 from .core.base import Invoice
 from .models import Cashu, Pegs, Promises, Proof
 
@@ -18,44 +19,44 @@ from cashu.core.base import MintKeyset
 from lnbits.db import Database, Connection
 
 
-class LedgerCrud:
+# class LedgerCrud:
-    """
+#     """
-    Database interface for Cashu mint.
+#     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.
-    """
+#     """
 
-    async def get_keyset(*args, **kwags):
+#     async def get_keyset(*args, **kwags):
 
-        return await get_keyset(*args, **kwags)
+#         return await get_keyset(*args, **kwags)
 
-    async def get_lightning_invoice(*args, **kwags):
+#     async def get_lightning_invoice(*args, **kwags):
 
-        return await get_lightning_invoice(*args, **kwags)
+#         return await get_lightning_invoice(*args, **kwags)
 
-    async def get_proofs_used(*args, **kwags):
+#     async def get_proofs_used(*args, **kwags):
 
-        return await get_proofs_used(*args, **kwags)
+#         return await get_proofs_used(*args, **kwags)
 
-    async def invalidate_proof(*args, **kwags):
+#     async def invalidate_proof(*args, **kwags):
 
-        return await invalidate_proof(*args, **kwags)
+#         return await invalidate_proof(*args, **kwags)
 
-    async def store_keyset(*args, **kwags):
+#     async def store_keyset(*args, **kwags):
 
-        return await store_keyset(*args, **kwags)
+#         return await store_keyset(*args, **kwags)
 
-    async def store_lightning_invoice(*args, **kwags):
+#     async def store_lightning_invoice(*args, **kwags):
 
-        return await store_lightning_invoice(*args, **kwags)
+#         return await store_lightning_invoice(*args, **kwags)
 
-    async def store_promise(*args, **kwags):
+#     async def store_promise(*args, **kwags):
 
-        return await store_promise(*args, **kwags)
+#         return await store_promise(*args, **kwags)
 
-    async def update_lightning_invoice(*args, **kwags):
+#     async def update_lightning_invoice(*args, **kwags):
 
-        return await update_lightning_invoice(*args, **kwags)
+#         return await update_lightning_invoice(*args, **kwags)
 
 
 async def create_cashu(wallet_id: str, data: Cashu) -> Cashu:
@@ -132,9 +133,9 @@ async def delete_cashu(cashu_id) -> None:
     await db.execute("DELETE FROM cashu.cashu WHERE id = ?", (cashu_id,))
 
 
-##########################################
+# ##########################################
-###############MINT STUFF#################
+# ###############MINT STUFF#################
-##########################################
+# ##########################################
 
 
 async def store_promises(
@@ -241,55 +242,55 @@ async def update_lightning_invoice(cashu_id: str, hash: str, issued: bool):
 ##############################
 
 
-async def store_keyset(
+# async def store_keyset(
-    keyset: MintKeyset,
+#     keyset: MintKeyset,
-    db: Database = None,
+#     db: Database = None,
-    conn: Optional[Connection] = None,
+#     conn: Optional[Connection] = None,
-):
+# ):
 
-    await (conn or db).execute(  # type: ignore
+#     await (conn or db).execute(  # type: ignore
-        """
+#         """
-        INSERT INTO cashu.keysets
+#         INSERT INTO cashu.keysets
-          (id, derivation_path, valid_from, valid_to, first_seen, active, version)
+#           (id, derivation_path, valid_from, valid_to, first_seen, active, version)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
+#         VALUES (?, ?, ?, ?, ?, ?, ?)
-        """,
+#         """,
-        (
+#         (
-            keyset.id,
+#             keyset.id,
-            keyset.derivation_path,
+#             keyset.derivation_path,
-            keyset.valid_from or db.timestamp_now,
+#             keyset.valid_from or db.timestamp_now,
-            keyset.valid_to or db.timestamp_now,
+#             keyset.valid_to or db.timestamp_now,
-            keyset.first_seen or db.timestamp_now,
+#             keyset.first_seen or db.timestamp_now,
-            True,
+#             True,
-            keyset.version,
+#             keyset.version,
-        ),
+#         ),
-    )
+#     )
 
 
-async def get_keyset(
+# async def get_keyset(
-    id: str = None,
+#     id: str = None,
-    derivation_path: str = "",
+#     derivation_path: str = "",
-    db: Database = None,
+#     db: Database = None,
-    conn: Optional[Connection] = None,
+#     conn: Optional[Connection] = None,
-):
+# ):
-    clauses = []
+#     clauses = []
-    values: List[Any] = []
+#     values: List[Any] = []
-    clauses.append("active = ?")
+#     clauses.append("active = ?")
-    values.append(True)
+#     values.append(True)
-    if id:
+#     if id:
-        clauses.append("id = ?")
+#         clauses.append("id = ?")
-        values.append(id)
+#         values.append(id)
-    if derivation_path:
+#     if derivation_path:
-        clauses.append("derivation_path = ?")
+#         clauses.append("derivation_path = ?")
-        values.append(derivation_path)
+#         values.append(derivation_path)
-    where = ""
+#     where = ""
-    if clauses:
+#     if clauses:
-        where = f"WHERE {' AND '.join(clauses)}"
+#         where = f"WHERE {' AND '.join(clauses)}"
 
-    rows = await (conn or db).fetchall(  # type: ignore
+#     rows = await (conn or db).fetchall(  # type: ignore
-        f"""
+#         f"""
-        SELECT * from cashu.keysets
+#         SELECT * from cashu.keysets
-        {where}
+#         {where}
-        """,
+#         """,
-        tuple(values),
+#         tuple(values),
-    )
+#     )
-    return [MintKeyset.from_row(row) for row in rows]
+#     return [MintKeyset.from_row(row) for row in rows]

lnbits/extensions/cashu/migrations.py

@@ -1 +1,148 @@
-# this extension will use the migration_module module cashu.mint.migrations (see config.json)
+async def m001_initial(db):
+    """
+    Initial cashu table.
+    """
+    await db.execute(
+        """
+        CREATE TABLE cashu.cashu (
+            id TEXT PRIMARY KEY,
+            wallet TEXT NOT NULL,
+            name TEXT NOT NULL,
+            tickershort TEXT DEFAULT 'sats',
+            fraction BOOL,
+            maxsats INT,
+            coins INT,
+            prvkey TEXT NOT NULL,
+            pubkey TEXT NOT NULL
+        );
+    """
+    )
+
+    """
+    Initial cashus table.
+    """
+    await db.execute(
+        """
+        CREATE TABLE cashu.pegs (
+            id TEXT PRIMARY KEY,
+            wallet TEXT NOT NULL,
+            inout BOOL NOT NULL,
+            amount INT
+        );
+    """
+    )
+
+
+# async def m001_initial(db):
+#     await db.execute(
+#         """
+#             CREATE TABLE IF NOT EXISTS cashu.promises (
+#                 amount INTEGER NOT NULL,
+#                 B_b TEXT NOT NULL,
+#                 C_b TEXT NOT NULL,
+
+#                 UNIQUE (B_b)
+
+#             );
+#         """
+#     )
+
+#     await db.execute(
+#         """
+#             CREATE TABLE IF NOT EXISTS cashu.proofs_used (
+#                 amount INTEGER NOT NULL,
+#                 C TEXT NOT NULL,
+#                 secret TEXT NOT NULL,
+
+#                 UNIQUE (secret)
+
+#             );
+#         """
+#     )
+
+#     await db.execute(
+#         """
+#             CREATE TABLE IF NOT EXISTS cashu.invoices (
+#                 amount INTEGER NOT NULL,
+#                 pr TEXT NOT NULL,
+#                 hash TEXT NOT NULL,
+#                 issued BOOL NOT NULL,
+
+#                 UNIQUE (hash)
+
+#             );
+#         """
+#     )
+
+# await db.execute(
+#     """
+#     CREATE VIEW IF NOT EXISTS cashu.balance_issued AS
+#     SELECT COALESCE(SUM(s), 0) AS balance FROM (
+#         SELECT SUM(amount) AS s
+#         FROM cashu.promises
+#         WHERE amount > 0
+#     );
+# """
+# )
+
+# await db.execute(
+#     """
+#     CREATE VIEW IF NOT EXISTS cashu.balance_used AS
+#     SELECT COALESCE(SUM(s), 0) AS balance FROM (
+#         SELECT SUM(amount) AS s
+#         FROM cashu.proofs_used
+#         WHERE amount > 0
+#     );
+# """
+# )
+
+# await db.execute(
+#     """
+#     CREATE VIEW IF NOT EXISTS cashu.balance AS
+#     SELECT s_issued - s_used AS balance FROM (
+#         SELECT bi.balance AS s_issued, bu.balance AS s_used
+#         FROM cashu.balance_issued bi
+#         CROSS JOIN balance_used bu
+#     );
+# """
+# )
+
+
+# async def m003_mint_keysets(db):
+#     """
+#     Stores mint keysets from different mints and epochs.
+#     """
+#     await db.execute(
+#         f"""
+#             CREATE TABLE IF NOT EXISTS cashu.keysets (
+#                 id TEXT NOT NULL,
+#                 derivation_path TEXT,
+#                 valid_from TIMESTAMP NOT NULL DEFAULT {db.timestamp_now},
+#                 valid_to TIMESTAMP NOT NULL DEFAULT {db.timestamp_now},
+#                 first_seen TIMESTAMP NOT NULL DEFAULT {db.timestamp_now},
+#                 active BOOL DEFAULT TRUE,
+
+#                 UNIQUE (derivation_path)
+
+#             );
+#         """
+#     )
+#     await db.execute(
+#         f"""
+#             CREATE TABLE IF NOT EXISTS cashu.mint_pubkeys (
+#                 id TEXT NOT NULL,
+#                 amount INTEGER NOT NULL,
+#                 pubkey TEXT NOT NULL,
+
+#                 UNIQUE (id, pubkey)
+
+#             );
+#         """
+#     )
+
+
+# async def m004_keysets_add_version(db):
+#     """
+#     Column that remembers with which version
+#     """
+#     await db.execute("ALTER TABLE cashu.keysets ADD COLUMN version TEXT")

lnbits/extensions/cashu/tasks.py

@@ -12,13 +12,13 @@ from .crud import get_cashu
 import sys
 
 sys.path.append("/Users/cc/git/cashu")
-# from cashu.mint import migrations
+from cashu.mint import migrations
-# from cashu.core.migrations import migrate_databases
+from cashu.core.migrations import migrate_databases
 from . import db, ledger
 
 
 async def startup_cashu_mint():
-    # await migrate_databases(db, migrations)
+    await migrate_databases(db, migrations)
     await ledger.load_used_proofs()
     await ledger.init_keysets()
     print(ledger.get_keyset())

lnbits/extensions/cashu/views_api.py

@@ -29,6 +29,13 @@ from .crud import (
     update_lightning_invoice,
 )
 
+# from cashu.mint.crud import (
+#     get_lightning_invoice,
+#     store_lightning_invoice,
+#     store_promise,
+#     update_lightning_invoice,
+# )
+
 # from .ledger import mint, request_mint
 from .mint import generate_promises, get_pubkeys, melt, split
 from .models import (