heierbtc/lnbits
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: format

Browse Source
This commit is contained in:
Vlad Stan 2022-10-07 11:17:02 +03:00 committed by dni ⚡
parent 2c54c240ba
commit 104aca33ff
15 changed files with 992 additions and 610 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lnbits/extensions/cashu/__init__.py
View File

@ -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))

84
lnbits/extensions/cashu/crud.py
View File

@ -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()
@ -25,7 +21,7 @@ async def create_cashu(wallet_id: str, data: Cashu) -> Cashu:
mnemonic = bip39.mnemonic_from_bytes(entropy)
seed = bip39.mnemonic_to_seed(mnemonic)
root = bip32.HDKey.from_seed(seed, version=NETWORKS["main"]["xprv"])
bip44_xprv = root.derive("m/44h/1h/0h")
bip44_xpub = bip44_xprv.to_public()
@ -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(),
),
)
@ -57,11 +53,16 @@ async def update_cashu_keys(cashu_id, wif: str = None) -> Optional[Cashu]:
mnemonic = bip39.mnemonic_from_bytes(entropy)
seed = bip39.mnemonic_to_seed(mnemonic)
root = bip32.HDKey.from_seed(seed, version=NETWORKS["main"]["xprv"])
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,
B_: str,
C_: str,
cashu_id
):
async def store_promise(amount: int, 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(
proof: Proof,
cashu_id
):
async def invalidate_proof(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 = ?",
(

100
lnbits/extensions/cashu/ledger.py
View File

@ -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(
amount, B_=B_.serialize().hex(), C_=C_.serialize().hex()
)
await store_promise(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={
"tag": "Cashu"
},
extra={"tag": "Cashu"},
)
invoice = Invoice(
@ -137,15 +160,23 @@ 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")
"""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 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,11 +188,14 @@ 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")
raise Exception(f"Could not find Cashu")
"""Invalidates proofs and pays a Lightning invoice."""
# if not LIGHTNING:
total = sum([p["amount"] for p in proofs])
@ -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")
@ -226,18 +267,19 @@ async def split(proofs: List[Proof], amount: int, output_data: List[BlindedMessa
async def fee_reserve(amount_msat: int, cashu_id: str = Query(None)):
cashu = await get_cashu(cashu_id)
if not cashu:
raise Exception(f"Could not find Cashu")
raise Exception(f"Could not find Cashu")
"""Function for calculating the Lightning fee reserve"""
return max(
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:
raise Exception(f"Could not find Cashu")
raise Exception(f"Could not find Cashu")
"""Given an amount returns a list of amounts returned e.g. 13 is [1, 4, 8]."""
bits_amt = bin(amount)[::-1][:-2]
rv = []
@ -246,11 +288,12 @@ 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:
raise Exception(f"Could not find Cashu")
raise Exception(f"Could not find Cashu")
"""Generates x coordinate from the message hash and checks if the point lies on the curve.
If it does not, it tries computing again a new x coordinate from the hash of the coordinate."""
point = None
@ -280,10 +323,11 @@ 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:
raise Exception(f"Could not find Cashu")
raise Exception(f"Could not find Cashu")
C_ = B_.mult(a)
return C_

2
lnbits/extensions/cashu/migrations.py
View File

@ -75,4 +75,4 @@ async def m001_initial(db):
);
"""
)
)

8
lnbits/extensions/cashu/mint.py
View File

@ -1,16 +1,16 @@
from .models import Cashu
from .mint_helper import derive_keys, derive_pubkeys
from .models import Cashu
def get_pubkeys(xpriv: str):
"""Returns public keys for possible amounts."""
keys = derive_keys(xpriv)
pub_keys = derive_pubkeys(keys)
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
@ -29,4 +29,4 @@ def get_pubkeys(xpriv: str):
# promises = [
# await self._generate_promise(amount, B_) for B_, amount in zip(B_s, amounts)
# ]
# return promises
# return promises

5
lnbits/extensions/cashu/mint_helper.py
View File

@ -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)]}
return {amt: keys[amt].pubkey for amt in [2**i for i in range(MAX_ORDER)]}

9
lnbits/extensions/cashu/models.py
View File

@ -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
@ -142,4 +145,4 @@ class CheckPayload(BaseModel):
class MeltPayload(BaseModel):
proofs: List[Proof]
amount: int
invoice: str
invoice: str

1
lnbits/extensions/cashu/tasks.py
View File

@ -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)

3
lnbits/extensions/cashu/templates/cashu/_api_docs.html
View File

@ -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>

7
lnbits/extensions/cashu/templates/cashu/_cashu.html
View File

@ -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"
>Calle</a
>.</small
<a href="https://github.com/calle" target="_blank">Calle</a>.</small
>
</q-card-section>
</q-card>

160
lnbits/extensions/cashu/templates/cashu/index.html
View File

@ -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"
:pagination.sync="cashusTable.pagination">
<q-table
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-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>
<q-input
filled
dense
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-tooltip>Use with hedging extension to create a stablecoin!</q-tooltip>
<q-checkbox
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)"
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>
<q-input
v-if="!formDialog.data.fraction"
filled
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"
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>
<q-input
class="q-mt-md"
filled
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"
:disable="formDialog.data.wallet == null || formDialog.data.name == null" type="submit">Create Mint
<q-btn
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: 'name', align: 'left', label: 'Name', field: 'name' },
{name: 'id', align: 'left', label: 'ID', field: 'id'},
{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) {
@ -258,4 +344,4 @@
}
})
</script>
{% endblock %}
{% endblock %}

13
lnbits/extensions/cashu/templates/cashu/mint.html
View File

@ -5,14 +5,17 @@
<q-card-section class="q-pa-none">
<center>
<q-icon
name="account_balance"
class="text-grey"
style="font-size: 10rem"
></q-icon>
name="account_balance"
class="text-grey"
style="font-size: 10rem"
></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>

1104
lnbits/extensions/cashu/templates/cashu/wallet.html
View File

File diff suppressed because it is too large Load Diff

9
lnbits/extensions/cashu/views.py
View File

@ -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):

94
lnbits/extensions/cashu/views_api.py
View File

@ -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 .mint import get_pubkeys
from .core.base import CashuError
from .crud import (
create_cashu,
delete_cashu,
get_cashu,
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,
MeltPayload,
MintPayloads,
SplitPayload,
PayLnurlWData
CheckPayload,
Invoice,
MeltPayload,
MintPayloads,
PayLnurlWData,
Pegs,
SplitPayload,
)
########################################
@ -55,13 +55,12 @@ async def api_cashus(
@cashu_ext.post("/api/v1/cashus", status_code=HTTPStatus.CREATED)
async def api_cashu_create(
data: Cashu, wallet: WalletTypeInfo = Depends(get_key_type)
):
async def api_cashu_create(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 = []
B_s = []
print("############################ amount")
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))
@ -290,4 +316,4 @@ async def spli_coinst(payload: SplitPayload, cashu_id: str = Query(None)):
"""There was a problem with the split"""
raise Exception("could not split tokens.")
fst_promises, snd_promises = split_return
return {"fst": fst_promises, "snd": snd_promises}
return {"fst": fst_promises, "snd": snd_promises}