chore: format

lnbits/extensions/cashu/__init__.py

@@ -10,13 +10,16 @@ db = Database("ext_cashu")
 
 cashu_ext: APIRouter = APIRouter(prefix="/cashu", tags=["cashu"])
 
+
 def cashu_renderer():
     return template_renderer(["lnbits/extensions/cashu/templates"])
 
+
 from .tasks import wait_for_paid_invoices
 from .views import *  # noqa
 from .views_api import *  # noqa
 
+
 def cashu_start():
     loop = asyncio.get_event_loop()
     loop.create_task(catch_everything_and_restart(wait_for_paid_invoices))

lnbits/extensions/cashu/crud.py

@@ -1,22 +1,18 @@
 import os
-
+import random
+from binascii import hexlify, unhexlify
 from typing import List, Optional, Union
-from .core.base import Invoice
+
+from embit import bip32, bip39, ec, script
+from embit.networks import NETWORKS
+from loguru import logger
 
 from lnbits.helpers import urlsafe_short_hash
 
 from . import db
-from .models import Cashu, Pegs, Proof, Promises
+from .core.base import Invoice
+from .models import Cashu, Pegs, Promises, Proof
 
-from embit import script
-from embit import ec
-from embit.networks import NETWORKS
-from embit import bip32
-from embit import bip39
-from binascii import unhexlify, hexlify
-import random
-
-from loguru import logger
 
 async def create_cashu(wallet_id: str, data: Cashu) -> Cashu:
     cashu_id = urlsafe_short_hash()
@@ -43,7 +39,7 @@ async def create_cashu(wallet_id: str, data: Cashu) -> Cashu:
             data.maxsats,
             data.coins,
             bip44_xprv.to_base58(),
-            bip44_xpub.to_base58()
+            bip44_xpub.to_base58(),
         ),
     )
 
@@ -61,7 +57,12 @@ async def update_cashu_keys(cashu_id, wif: str = None) -> Optional[Cashu]:
     bip44_xprv = root.derive("m/44h/1h/0h")
     bip44_xpub = bip44_xprv.to_public()
 
-    await db.execute("UPDATE cashu.cashu SET prv = ?, pub = ? WHERE id = ?", bip44_xprv.to_base58(), bip44_xpub.to_base58(), cashu_id)
+    await db.execute(
+        "UPDATE cashu.cashu SET prv = ?, pub = ? WHERE id = ?",
+        bip44_xprv.to_base58(),
+        bip44_xpub.to_base58(),
+        cashu_id,
+    )
     row = await db.fetchone("SELECT * FROM cashu.cashu WHERE id = ?", (cashu_id,))
     return Cashu(**row) if row else None
 
@@ -91,12 +92,8 @@ async def delete_cashu(cashu_id) -> None:
 ###############MINT STUFF#################
 ##########################################
 
-async def store_promise(
+
-    amount: int,
+async def store_promise(amount: int, B_: str, C_: str, cashu_id):
-    B_: str,
-    C_: str,
-    cashu_id
-):
     promise_id = urlsafe_short_hash()
 
     await db.execute(
@@ -105,28 +102,25 @@ async def store_promise(
           (id, amount, B_b, C_b, cashu_id)
         VALUES (?, ?, ?, ?, ?)
         """,
-        (
+        (promise_id, amount, str(B_), str(C_), cashu_id),
-            promise_id,
-            amount,
-            str(B_),
-            str(C_),
-            cashu_id
-        ),
     )
 
+
 async def get_promises(cashu_id) -> Optional[Cashu]:
-    row = await db.fetchall("SELECT * FROM cashu.promises WHERE cashu_id = ?", (promises_id,))
+    row = await db.fetchall(
+        "SELECT * FROM cashu.promises WHERE cashu_id = ?", (promises_id,)
+    )
     return Promises(**row) if row else None
 
+
 async def get_proofs_used(cashu_id):
-    rows = await db.fetchall("SELECT secret from cashu.proofs_used WHERE id = ?", (cashu_id,))
+    rows = await db.fetchall(
+        "SELECT secret from cashu.proofs_used WHERE id = ?", (cashu_id,)
+    )
     return [row[0] for row in rows]
 
 
-async def invalidate_proof(
+async def invalidate_proof(proof: Proof, cashu_id):
-    proof: Proof,
-    cashu_id
-):
     invalidate_proof_id = urlsafe_short_hash()
     await (conn or db).execute(
         """
@@ -134,20 +128,10 @@ async def invalidate_proof(
           (id, amount, C, secret, cashu_id)
         VALUES (?, ?, ?, ?, ?)
         """,
-        (
+        (invalidate_proof_id, proof.amount, str(proof.C), str(proof.secret), cashu_id),
-            invalidate_proof_id,
-            proof.amount,
-            str(proof.C),
-            str(proof.secret),
-            cashu_id
-        ),
     )
 
 
-
-
-
-
 ########################################
 ############ MINT INVOICES #############
 ########################################
@@ -169,18 +153,22 @@ async def store_lightning_invoice(cashu_id: str, invoice: Invoice):
         ),
     )
 
+
 async def get_lightning_invoice(cashu_id: str, hash: str):
     row = await db.fetchone(
         """
         SELECT * from invoices
         WHERE cashu_id =? AND hash = ?
         """,
-        (cashu_id, hash,),
+        (
+            cashu_id,
+            hash,
+        ),
     )
     return Invoice.from_row(row)
 
 
-async def update_lightning_invoice(cashu_id: str, hash: str,  issued: bool):
+async def update_lightning_invoice(cashu_id: str, hash: str, issued: bool):
     await db.execute(
         "UPDATE invoices SET issued = ? WHERE cashu_id = ? AND hash = ?",
         (

lnbits/extensions/cashu/ledger.py

@@ -1,13 +1,15 @@
 import hashlib
 from typing import List, Set
 
-from .models import BlindedMessage, BlindedSignature, Invoice, Proof
-from secp256k1 import PublicKey, PrivateKey
-
 from fastapi import Query
-from .crud import get_cashu
+from secp256k1 import PrivateKey, PublicKey
+
 from lnbits.core.services import check_transaction_status, create_invoice
 
+from .crud import get_cashu
+from .models import BlindedMessage, BlindedSignature, Invoice, Proof
+
+
 def _derive_keys(master_key: str, cashu_id: str = Query(None)):
     """Deterministic derivation of keys for 2^n values."""
     return {
@@ -21,29 +23,34 @@ def _derive_keys(master_key: str, cashu_id: str = Query(None)):
         for i in range(MAX_ORDER)
     }
 
+
 def _derive_pubkeys(keys: List[PrivateKey], cashu_id: str = Query(None)):
     return {amt: keys[amt].pubkey for amt in [2**i for i in range(MAX_ORDER)]}
 
-async def _generate_promises(amounts: List[int], B_s: List[str], cashu_id: str = Query(None)):
+
+async def _generate_promises(
+    amounts: List[int], B_s: List[str], cashu_id: str = Query(None)
+):
     """Generates promises that sum to the given amount."""
     return [
         await self._generate_promise(amount, PublicKey(bytes.fromhex(B_), raw=True))
         for (amount, B_) in zip(amounts, B_s)
     ]
 
+
 async def _generate_promise(amount: int, B_: PublicKey, cashu_id: str = Query(None)):
     """Generates a promise for given amount and returns a pair (amount, C')."""
     secret_key = self.keys[amount]  # Get the correct key
     C_ = step2_bob(B_, secret_key)
-    await store_promise(
+    await store_promise(amount, B_=B_.serialize().hex(), C_=C_.serialize().hex())
-        amount, B_=B_.serialize().hex(), C_=C_.serialize().hex()
-    )
     return BlindedSignature(amount=amount, C_=C_.serialize().hex())
 
+
 def _check_spendable(proof: Proof, cashu_id: str = Query(None)):
     """Checks whether the proof was already spent."""
     return not proof.secret in self.proofs_used
 
+
 def _verify_proof(proof: Proof, cashu_id: str = Query(None)):
     """Verifies that the proof of promise was issued by this ledger."""
     if not self._check_spendable(proof):
@@ -52,7 +59,13 @@ def _verify_proof(proof: Proof, cashu_id: str = Query(None)):
     C = PublicKey(bytes.fromhex(proof.C), raw=True)
     return verify(secret_key, C, proof.secret)
 
-def _verify_outputs(total: int, amount: int, output_data: List[BlindedMessage], cashu_id: str = Query(None)):
+
+def _verify_outputs(
+    total: int,
+    amount: int,
+    output_data: List[BlindedMessage],
+    cashu_id: str = Query(None),
+):
     """Verifies the expected split was correctly computed"""
     fst_amt, snd_amt = total - amount, amount  # we have two amounts to split to
     fst_outputs = amount_split(fst_amt)
@@ -61,7 +74,10 @@ def _verify_outputs(total: int, amount: int, output_data: List[BlindedMessage],
     given = [o.amount for o in output_data]
     return given == expected
 
-def _verify_no_duplicates(proofs: List[Proof], output_data: List[BlindedMessage], cashu_id: str = Query(None)):
+
+def _verify_no_duplicates(
+    proofs: List[Proof], output_data: List[BlindedMessage], cashu_id: str = Query(None)
+):
     secrets = [p.secret for p in proofs]
     if len(secrets) != len(list(set(secrets))):
         return False
@@ -70,6 +86,7 @@ def _verify_no_duplicates(proofs: List[Proof], output_data: List[BlindedMessage]
         return False
     return True
 
+
 def _verify_split_amount(amount: int, cashu_id: str = Query(None)):
     """Split amount like output amount can't be negative or too big."""
     try:
@@ -78,6 +95,7 @@ def _verify_split_amount(amount: int, cashu_id: str = Query(None)):
         # For better error message
         raise Exception("invalid split amount: " + str(amount))
 
+
 def _verify_amount(amount: int, cashu_id: str = Query(None)):
     """Any amount used should be a positive integer not larger than 2^MAX_ORDER."""
     valid = isinstance(amount, int) and amount > 0 and amount < 2**MAX_ORDER
@@ -85,12 +103,16 @@ def _verify_amount(amount: int, cashu_id: str = Query(None)):
         raise Exception("invalid amount: " + str(amount))
     return amount
 
-def _verify_equation_balanced(proofs: List[Proof], outs: List[BlindedMessage], cashu_id: str = Query(None)):
+
+def _verify_equation_balanced(
+    proofs: List[Proof], outs: List[BlindedMessage], cashu_id: str = Query(None)
+):
     """Verify that Σoutputs - Σinputs = 0."""
     sum_inputs = sum(self._verify_amount(p.amount) for p in proofs)
     sum_outputs = sum(self._verify_amount(p.amount) for p in outs)
     assert sum_outputs - sum_inputs == 0
 
+
 def _get_output_split(amount: int, cashu_id: str):
     """Given an amount returns a list of amounts returned e.g. 13 is [1, 4, 8]."""
     self._verify_amount(amount)
@@ -101,6 +123,7 @@ def _get_output_split(amount: int, cashu_id: str):
             rv.append(2**pos)
     return rv
 
+
 async def _invalidate_proofs(proofs: List[Proof], cashu_id: str = Query(None)):
     """Adds secrets of proofs to the list of knwon secrets and stores them in the db."""
     # Mark proofs as used and prepare new promises
@@ -110,10 +133,12 @@ async def _invalidate_proofs(proofs: List[Proof], cashu_id: str = Query(None)):
     for p in proofs:
         await invalidate_proof(p)
 
+
 def get_pubkeys(cashu_id: str = Query(None)):
     """Returns public keys for possible amounts."""
     return {a: p.serialize().hex() for a, p in self.pub_keys.items()}
 
+
 async def request_mint(amount, cashu_id: str = Query(None)):
     cashu = await get_cashu(cashu_id)
     if not cashu:
@@ -125,9 +150,7 @@ async def request_mint(amount, cashu_id: str = Query(None)):
         amount=amount,
         memo=cashu.name,
         unhashed_description=cashu.name.encode("utf-8"),
-        extra={
+        extra={"tag": "Cashu"},
-            "tag": "Cashu"
-        },
     )
 
     invoice = Invoice(
@@ -137,7 +160,13 @@ async def request_mint(amount, cashu_id: str = Query(None)):
         raise Exception(f"Could not create Lightning invoice.")
     return payment_request, payment_hash
 
-async def mint(B_s: List[PublicKey], amounts: List[int], payment_hash: str = Query(None), cashu_id: str = Query(None)):
+
+async def mint(
+    B_s: List[PublicKey],
+    amounts: List[int],
+    payment_hash: str = Query(None),
+    cashu_id: str = Query(None),
+):
     cashu = await get_cashu(cashu_id)
     if not cashu:
         raise Exception(f"Could not find Cashu")
@@ -145,7 +174,9 @@ async def mint(B_s: List[PublicKey], amounts: List[int], payment_hash: str = Que
     """Mints a promise for coins for B_."""
     # check if lightning invoice was paid
     if payment_hash:
-        if not await check_transaction_status(wallet_id=cashu.wallet, payment_hash=payment_hash):
+        if not await check_transaction_status(
+            wallet_id=cashu.wallet, payment_hash=payment_hash
+        ):
             raise Exception("Lightning invoice not paid yet.")
 
     for amount in amounts:
@@ -157,7 +188,10 @@ async def mint(B_s: List[PublicKey], amounts: List[int], payment_hash: str = Que
     ]
     return promises
 
-async def melt(proofs: List[Proof], amount: int, invoice: str, cashu_id: str = Query(None)):
+
+async def melt(
+    proofs: List[Proof], amount: int, invoice: str, cashu_id: str = Query(None)
+):
     cashu = await get_cashu(cashu_id)
     if not cashu:
         raise Exception(f"Could not find Cashu")
@@ -181,6 +215,7 @@ async def melt(proofs: List[Proof], amount: int, invoice: str, cashu_id: str = Q
         await self._invalidate_proofs(proofs)
     return status, payment_hash
 
+
 async def check_spendable(proofs: List[Proof], cashu_id: str = Query(None)):
     cashu = await get_cashu(cashu_id)
     if not cashu:
@@ -189,7 +224,13 @@ async def check_spendable(proofs: List[Proof], cashu_id: str = Query(None)):
     """Checks if all provided proofs are valid and still spendable (i.e. have not been spent)."""
     return {i: self._check_spendable(p) for i, p in enumerate(proofs)}
 
-async def split(proofs: List[Proof], amount: int, output_data: List[BlindedMessage], cashu_id: str = Query(None)):
+
+async def split(
+    proofs: List[Proof],
+    amount: int,
+    output_data: List[BlindedMessage],
+    cashu_id: str = Query(None),
+):
     cashu = await get_cashu(cashu_id)
     if not cashu:
         raise Exception(f"Could not find Cashu")
@@ -233,6 +274,7 @@ async def fee_reserve(amount_msat: int, cashu_id: str = Query(None)):
         int(LIGHTNING_RESERVE_FEE_MIN), int(amount_msat * LIGHTNING_FEE_PERCENT / 100.0)
     )
 
+
 async def amount_split(amount, cashu_id: str):
     cashu = await get_cashu(cashu_id)
     if not cashu:
@@ -246,6 +288,7 @@ async def amount_split(amount, cashu_id: str):
             rv.append(2**pos)
     return rv
 
+
 async def hash_to_point(secret_msg, cashu_id: str = Query(None)):
     cashu = await get_cashu(cashu_id)
     if not cashu:
@@ -280,6 +323,7 @@ async def step1_alice(secret_msg, cashu_id: str = Query(None)):
     B_ = Y + r.pubkey
     return B_, r
 
+
 async def step2_bob(B_, a, cashu_id: str = Query(None)):
     cashu = await get_cashu(cashu_id)
     if not cashu:

lnbits/extensions/cashu/mint.py

@@ -1,6 +1,5 @@
-
-from .models import Cashu
 from .mint_helper import derive_keys, derive_pubkeys
+from .models import Cashu
 
 
 def get_pubkeys(xpriv: str):
@@ -11,6 +10,7 @@ def get_pubkeys(xpriv: str):
 
     return {a: p.serialize().hex() for a, p in pub_keys.items()}
 
+
 # async def mint(self, B_s: List[PublicKey], amounts: List[int], payment_hash=None):
 #     """Mints a promise for coins for B_."""
 #     # check if lightning invoice was paid

lnbits/extensions/cashu/mint_helper.py

@@ -1,10 +1,12 @@
 import hashlib
 from typing import List, Set
+
 from .core.secp import PrivateKey, PublicKey
 
 # todo: extract const
 MAX_ORDER = 64
 
+
 def derive_keys(master_key: str):
     """Deterministic derivation of keys for 2^n values."""
     return {
@@ -18,5 +20,6 @@ def derive_keys(master_key: str):
         for i in range(MAX_ORDER)
     }
 
+
 def derive_pubkeys(keys: List[PrivateKey]):
     return {amt: keys[amt].pubkey for amt in [2**i for i in range(MAX_ORDER)]}

lnbits/extensions/cashu/models.py

@@ -1,5 +1,5 @@
 from sqlite3 import Row
-from typing import Optional, List
+from typing import List, Optional
 
 from fastapi import Query
 from pydantic import BaseModel
@@ -20,20 +20,22 @@ class Cashu(BaseModel):
     def from_row(cls, row: Row) -> "TPoS":
         return cls(**dict(row))
 
+
 class Pegs(BaseModel):
     id: str
     wallet: str
     inout: str
     amount: str
 
-
     @classmethod
     def from_row(cls, row: Row) -> "TPoS":
         return cls(**dict(row))
 
+
 class PayLnurlWData(BaseModel):
     lnurl: str
 
+
 class Promises(BaseModel):
     id: str
     amount: int
@@ -41,6 +43,7 @@ class Promises(BaseModel):
     C_b: str
     cashu_id: str
 
+
 class Proof(BaseModel):
     amount: int
     secret: str

lnbits/extensions/cashu/tasks.py

@@ -9,6 +9,7 @@ from lnbits.tasks import internal_invoice_queue, register_invoice_listener
 
 from .crud import get_cashu
 
+
 async def wait_for_paid_invoices():
     invoice_queue = asyncio.Queue()
     register_invoice_listener(invoice_queue)

lnbits/extensions/cashu/templates/cashu/_api_docs.html

@@ -71,7 +71,8 @@
         <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
         <code
           >curl -X DELETE {{ request.base_url
-          }}cashu/api/v1/cashus/&lt;cashu_id&gt; -H "X-Api-Key: &lt;admin_key&gt;"
+          }}cashu/api/v1/cashus/&lt;cashu_id&gt; -H "X-Api-Key:
+          &lt;admin_key&gt;"
         </code>
       </q-card-section>
     </q-card>

lnbits/extensions/cashu/templates/cashu/_cashu.html

@@ -2,13 +2,12 @@
   <q-card>
     <q-card-section>
       <p>
-        Make Ecash mints with peg in/out to a wallet, that can create and manage ecash.
+        Make Ecash mints with peg in/out to a wallet, that can create and manage
+        ecash.
       </p>
       <small
         >Created by
-        <a href="https://github.com/calle" target="_blank"
+        <a href="https://github.com/calle" target="_blank">Calle</a>.</small
-          >Calle</a
-        >.</small
       >
     </q-card-section>
   </q-card>

lnbits/extensions/cashu/templates/cashu/index.html

@@ -4,7 +4,9 @@
   <div class="col-12 col-md-8 col-lg-7 q-gutter-y-md">
     <q-card>
       <q-card-section>
-        <q-btn unelevated color="primary" @click="formDialog.show = true">New Mint</q-btn>
+        <q-btn unelevated color="primary" @click="formDialog.show = true"
+          >New Mint</q-btn
+        >
       </q-card-section>
     </q-card>
 
@@ -18,8 +20,14 @@
             <q-btn flat color="grey" @click="exportCSV">Export to CSV</q-btn>
           </div>
         </div>
-        <q-table dense flat :data="cashus" row-key="id" :columns="cashusTable.columns"
+        <q-table
-          :pagination.sync="cashusTable.pagination">
+          dense
+          flat
+          :data="cashus"
+          row-key="id"
+          :columns="cashusTable.columns"
+          :pagination.sync="cashusTable.pagination"
+        >
           {% raw %}
           <template v-slot:header="props">
             <q-tr :props="props">
@@ -34,23 +42,43 @@
           <template v-slot:body="props">
             <q-tr :props="props">
               <q-td auto-width>
-                <q-btn unelevated dense size="xs" icon="launch" :color="($q.dark.isActive) ? 'grey-7' : 'grey-5'"
+                <q-btn
+                  unelevated
+                  dense
+                  size="xs"
+                  icon="launch"
+                  :color="($q.dark.isActive) ? 'grey-7' : 'grey-5'"
                   type="a"
                   :href="'wallet/?tsh=' + props.row.tickershort + '&mnt=' + hostname + props.row.id + '&nme=' + props.row.name"
-                  target="_blank"><q-tooltip>Shareable wallet page</q-tooltip></q-btn>
+                  target="_blank"
+                  ><q-tooltip>Shareable wallet page</q-tooltip></q-btn
+                >
 
-                  <q-btn unelevated dense size="xs" icon="account_balance" :color="($q.dark.isActive) ? 'grey-7' : 'grey-5'"
+                <q-btn
+                  unelevated
+                  dense
+                  size="xs"
+                  icon="account_balance"
+                  :color="($q.dark.isActive) ? 'grey-7' : 'grey-5'"
                   type="a"
                   :href="'mint/' + props.row.id"
-                  target="_blank"><q-tooltip>Shareable mint page</q-tooltip></q-btn>
+                  target="_blank"
-
+                  ><q-tooltip>Shareable mint page</q-tooltip></q-btn
+                >
               </q-td>
               <q-td v-for="col in props.cols" :key="col.name" :props="props">
                 {{ (col.name == 'tip_options' && col.value ?
                 JSON.parse(col.value).join(", ") : col.value) }}
               </q-td>
               <q-td auto-width>
-                <q-btn flat dense size="xs" @click="deleteMint(props.row.id)" icon="cancel" color="pink"></q-btn>
+                <q-btn
+                  flat
+                  dense
+                  size="xs"
+                  @click="deleteMint(props.row.id)"
+                  icon="cancel"
+                  color="pink"
+                ></q-btn>
               </q-td>
             </q-tr>
           </template>
@@ -79,34 +107,90 @@
   <q-dialog v-model="formDialog.show" position="top" @hide="closeFormDialog">
     <q-card class="q-pa-lg q-pt-xl" style="width: 500px">
       <q-form @submit="createMint" class="q-gutter-md">
-        <q-input filled dense v-model.trim="formDialog.data.name" label="Mint Name" placeholder="Cashu Mint"></q-input>
+        <q-input
-        <q-select filled dense emit-value v-model="formDialog.data.wallet" :options="g.user.walletOptions"
+          filled
-          label="Wallet *" ></q-select>
+          dense
-        <q-toggle v-model="toggleAdvanced" label="Show advanced options"></q-toggle>
+          v-model.trim="formDialog.data.name"
+          label="Mint Name"
+          placeholder="Cashu Mint"
+        ></q-input>
+        <q-select
+          filled
+          dense
+          emit-value
+          v-model="formDialog.data.wallet"
+          :options="g.user.walletOptions"
+          label="Wallet *"
+        ></q-select>
+        <q-toggle
+          v-model="toggleAdvanced"
+          label="Show advanced options"
+        ></q-toggle>
         <div v-show="toggleAdvanced">
           <div class="row">
             <div class="col-5">
-              <q-checkbox v-model="formDialog.data.fraction" color="primary" label="sats/coins?">
+              <q-checkbox
-                <q-tooltip>Use with hedging extension to create a stablecoin!</q-tooltip>
+                v-model="formDialog.data.fraction"
+                color="primary"
+                label="sats/coins?"
+              >
+                <q-tooltip
+                  >Use with hedging extension to create a stablecoin!</q-tooltip
+                >
               </q-checkbox>
             </div>
             <div class="col-7">
-              <q-input v-if="!formDialog.data.fraction" filled dense type="number" v-model.trim="formDialog.data.cost" label="Sat coin cost (optional)"
+              <q-input
-                value="1" type="number"></q-input>
+                v-if="!formDialog.data.fraction"
-                <q-input v-if="!formDialog.data.fraction" filled dense v-model.trim="formDialog.data.tickershort" label="Ticker shorthand" placeholder="CC"
+                filled
-          #></q-input>
+                dense
+                type="number"
+                v-model.trim="formDialog.data.cost"
+                label="Sat coin cost (optional)"
+                value="1"
+                type="number"
+              ></q-input>
+              <q-input
+                v-if="!formDialog.data.fraction"
+                filled
+                dense
+                v-model.trim="formDialog.data.tickershort"
+                label="Ticker shorthand"
+                placeholder="CC"
+                #
+              ></q-input>
             </div>
           </div>
-          <q-input class="q-mt-md" filled dense type="number" v-model.trim="formDialog.data.maxsats"
+          <q-input
-            label="Maximum mint liquidity (optional)" placeholder="∞"></q-input>
+            class="q-mt-md"
-          <q-input class="q-mt-md"  filled dense type="number" v-model.trim="formDialog.data.coins"
+            filled
-            label="Coins that 'exist' in mint (optional)" placeholder="∞"></q-input>
+            dense
+            type="number"
+            v-model.trim="formDialog.data.maxsats"
+            label="Maximum mint liquidity (optional)"
+            placeholder="∞"
+          ></q-input>
+          <q-input
+            class="q-mt-md"
+            filled
+            dense
+            type="number"
+            v-model.trim="formDialog.data.coins"
+            label="Coins that 'exist' in mint (optional)"
+            placeholder="∞"
+          ></q-input>
         </div>
         <div class="row q-mt-md">
-          <q-btn unelevated color="primary"
+          <q-btn
-            :disable="formDialog.data.wallet == null || formDialog.data.name == null" type="submit">Create Mint
+            unelevated
+            color="primary"
+            :disable="formDialog.data.wallet == null || formDialog.data.name == null"
+            type="submit"
+            >Create Mint
           </q-btn>
-          <q-btn v-close-popup flat color="grey" class="q-ml-auto">Cancel</q-btn>
+          <q-btn v-close-popup flat color="grey" class="q-ml-auto"
+            >Cancel</q-btn
+          >
         </div>
       </q-form>
     </q-card>
@@ -130,12 +214,12 @@
     data: function () {
       return {
         cashus: [],
-        hostname: location.protocol + "//" + location.host + "/cashu/mint/",
+        hostname: location.protocol + '//' + location.host + '/cashu/mint/',
         toggleAdvanced: false,
         cashusTable: {
           columns: [
-            { name: 'id', align: 'left', label: 'ID', field: 'id' },
+            {name: 'id', align: 'left', label: 'ID', field: 'id'},
-            { name: 'name', align: 'left', label: 'Name', field: 'name' },
+            {name: 'name', align: 'left', label: 'Name', field: 'name'},
             {
               name: 'tickershort',
               align: 'left',
@@ -165,7 +249,7 @@
               align: 'left',
               label: 'No. of coins',
               field: 'coins'
-            },
+            }
           ],
           pagination: {
             rowsPerPage: 10
@@ -173,7 +257,7 @@
         },
         formDialog: {
           show: false,
-          data: { fraction: false }
+          data: {fraction: false}
         }
       }
     },
@@ -203,7 +287,7 @@
         var data = {
           name: this.formDialog.data.name,
           tickershort: this.formDialog.data.tickershort,
-          maxliquid: this.formDialog.data.maxliquid,
+          maxliquid: this.formDialog.data.maxliquid
         }
         var self = this
 
@@ -211,7 +295,7 @@
           .request(
             'POST',
             '/cashu/api/v1/cashus',
-            _.findWhere(this.g.user.wallets, { id: this.formDialog.data.wallet })
+            _.findWhere(this.g.user.wallets, {id: this.formDialog.data.wallet})
               .inkey,
             data
           )
@@ -225,17 +309,19 @@
       },
       deleteMint: function (cashuId) {
         var self = this
-        var cashu = _.findWhere(this.cashus, { id: cashuId })
+        var cashu = _.findWhere(this.cashus, {id: cashuId})
         console.log(cashu)
 
         LNbits.utils
-          .confirmDialog('Are you sure you want to delete this Mint? It will suck for users.')
+          .confirmDialog(
+            'Are you sure you want to delete this Mint? It will suck for users.'
+          )
           .onOk(function () {
             LNbits.api
               .request(
                 'DELETE',
                 '/cashu/api/v1/cashus/' + cashuId,
-                _.findWhere(self.g.user.wallets, { id: cashu.wallet }).adminkey
+                _.findWhere(self.g.user.wallets, {id: cashu.wallet}).adminkey
               )
               .then(function (response) {
                 self.cashus = _.reject(self.cashus, function (obj) {

lnbits/extensions/cashu/templates/cashu/mint.html

@@ -5,14 +5,17 @@
       <q-card-section class="q-pa-none">
         <center>
           <q-icon
-          name="account_balance"
+            name="account_balance"
-          class="text-grey"
+            class="text-grey"
-          style="font-size: 10rem"
+            style="font-size: 10rem"
-        ></q-icon>
+          ></q-icon>
           <h3 class="q-my-none">{{ mint_name }}</h3>
           <br />
         </center>
-        <h5 class="q-my-none">Some data about mint here: <br/>* whether its online <br/>* Who to contact for support <br/>* etc...</h5>
+        <h5 class="q-my-none">
+          Some data about mint here: <br />* whether its online <br />* Who to
+          contact for support <br />* etc...
+        </h5>
       </q-card-section>
     </q-card>
   </div>

lnbits/extensions/cashu/views.py

@@ -22,14 +22,19 @@ async def index(request: Request, user: User = Depends(check_user_exists)):
         "cashu/index.html", {"request": request, "user": user.dict()}
     )
 
+
 @cashu_ext.get("/wallet")
 async def cashu(request: Request):
-    return cashu_renderer().TemplateResponse("cashu/wallet.html",{"request": request})
+    return cashu_renderer().TemplateResponse("cashu/wallet.html", {"request": request})
+
 
 @cashu_ext.get("/mint/{mintID}")
 async def cashu(request: Request, mintID):
     cashu = await get_cashu(mintID)
-    return cashu_renderer().TemplateResponse("cashu/mint.html",{"request": request, "mint_name": cashu.name})
+    return cashu_renderer().TemplateResponse(
+        "cashu/mint.html", {"request": request, "mint_name": cashu.name}
+    )
+
 
 @cashu_ext.get("/manifest/{cashu_id}.webmanifest")
 async def manifest(cashu_id: str):

lnbits/extensions/cashu/views_api.py

@@ -1,5 +1,4 @@
 from http import HTTPStatus
-from secp256k1 import PublicKey
 from typing import Union
 
 import httpx
@@ -7,35 +6,36 @@ from fastapi import Query
 from fastapi.params import Depends
 from lnurl import decode as decode_lnurl
 from loguru import logger
+from secp256k1 import PublicKey
 from starlette.exceptions import HTTPException
 
 from lnbits.core.crud import get_user
-from lnbits.core.services import create_invoice
+from lnbits.core.services import check_transaction_status, create_invoice
 from lnbits.core.views.api import api_payment
 from lnbits.decorators import WalletTypeInfo, get_key_type, require_admin_key
-from .core.base import CashuError
+from lnbits.wallets.base import PaymentStatus
 
 from . import cashu_ext
-from .ledger import request_mint, mint
+from .core.base import CashuError
-from .mint import get_pubkeys
-
 from .crud import (
     create_cashu,
     delete_cashu,
     get_cashu,
     get_cashus,
+    get_lightning_invoice,
     store_lightning_invoice,
 )
-
+from .ledger import mint, request_mint
+from .mint import get_pubkeys
 from .models import (
     Cashu,
-    Invoice, 
-    Pegs, 
     CheckPayload,
+    Invoice,
     MeltPayload,
     MintPayloads,
+    PayLnurlWData,
+    Pegs,
     SplitPayload,
-    PayLnurlWData
 )
 
 ########################################
@@ -55,13 +55,12 @@ async def api_cashus(
 
 
 @cashu_ext.post("/api/v1/cashus", status_code=HTTPStatus.CREATED)
-async def api_cashu_create(
+async def api_cashu_create(data: Cashu, wallet: WalletTypeInfo = Depends(get_key_type)):
-    data: Cashu, wallet: WalletTypeInfo = Depends(get_key_type)
-):
     cashu = await create_cashu(wallet_id=wallet.wallet.id, data=data)
     logger.debug(cashu)
     return cashu.dict()
 
+
 @cashu_ext.post("/api/v1/cashus/upodatekeys", status_code=HTTPStatus.CREATED)
 async def api_cashu_update_keys(
     data: Cashu, wallet: WalletTypeInfo = Depends(get_key_type)
@@ -122,7 +121,8 @@ async def api_cashu_create_invoice(
 
 
 @cashu_ext.post(
-    "/api/v1/cashus/{cashu_id}/invoices/{payment_request}/pay", status_code=HTTPStatus.OK
+    "/api/v1/cashus/{cashu_id}/invoices/{payment_request}/pay",
+    status_code=HTTPStatus.OK,
 )
 async def api_cashu_pay_invoice(
     lnurl_data: PayLnurlWData, payment_request: str = None, cashu_id: str = None
@@ -203,26 +203,29 @@ async def api_cashu_check_invoice(cashu_id: str, payment_hash: str):
 #################MINT###################
 ########################################
 
-@cashu_ext.get("/api/v1/mint/keys/{cashu_id}",  status_code=HTTPStatus.OK)
+
-async def keys(cashu_id: str = Query(False), wallet: WalletTypeInfo = Depends(get_key_type)):
+@cashu_ext.get("/api/v1/mint/keys/{cashu_id}", status_code=HTTPStatus.OK)
+async def keys(
+    cashu_id: str = Query(False), wallet: WalletTypeInfo = Depends(get_key_type)
+):
     """Get the public keys of the mint"""
     mint = await get_cashu(cashu_id)
     if mint is None:
         raise HTTPException(
-                    status_code=HTTPStatus.NOT_FOUND, detail="Mint does not exist."
+            status_code=HTTPStatus.NOT_FOUND, detail="Mint does not exist."
-                )
+        )
     return get_pubkeys(mint.prvkey)
 
 
 @cashu_ext.get("/api/v1/mint/{cashu_id}")
 async def mint_pay_request(amount: int = 0, cashu_id: str = Query(None)):
     """Request minting of tokens. Server responds with a Lightning invoice."""
-    print('############################ amount', amount)
+
     cashu = await get_cashu(cashu_id)
     if cashu is None:
         raise HTTPException(
-                    status_code=HTTPStatus.NOT_FOUND, detail="Mint does not exist."
+            status_code=HTTPStatus.NOT_FOUND, detail="Mint does not exist."
-                )
+        )
 
     try:
         payment_hash, payment_request = await create_invoice(
@@ -237,20 +240,43 @@ async def mint_pay_request(amount: int = 0, cashu_id: str = Query(None)):
         await store_lightning_invoice(cashu_id, invoice)
     except Exception as e:
         logger.error(e)
-        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(cashu_id))
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(cashu_id)
+        )
 
     return {"pr": payment_request, "hash": payment_hash}
 
 
 @cashu_ext.post("/mint")
-async def mint_coins(payloads: MintPayloads, payment_hash: Union[str, None] = None, cashu_id: str = Query(None)):
+async def mint_coins(
+    payloads: MintPayloads,
+    payment_hash: Union[str, None] = None,
+    cashu_id: str = Query(None),
+):
     """
     Requests the minting of tokens belonging to a paid payment request.
-
     Call this endpoint after `GET /mint`.
     """
-    amounts = []
+    print("############################ amount")
-    B_s = []
+    cashu: Cashu = await get_cashu(cashu_id)
+    if cashu is None:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="Mint does not exist."
+        )
+    invoice: Invoice = get_lightning_invoice(cashu_id, payment_hash)
+    if invoice is None:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="Mint does not have this invoice."
+        )
+
+    status: PaymentStatus = check_transaction_status(cashu.wallet, payment_hash)
+    if status.paid == False:
+        raise HTTPException(
+            status_code=HTTPStatus.PAYMENT_REQUIRED, detail="Invoice not paid."
+        )
+
+    # amounts = []
+    # B_s = []
     # for payload in payloads.blinded_messages:
     #     amounts.append(payload.amount)
     #     B_s.append(PublicKey(bytes.fromhex(payload.B_), raw=True))