Multinut LND (#492)

* amount in melt request

* apply fee limit

* more error handling

* wip: signal flag in /info

* clean up multinut

* decode mypy error lndrest

* fix test

* fix tests

* signal feature and blindmessages_deprecated

* setting

* fix blindedsignature method

* fix tests

* mint info file

* test mpp with lnd regtest

* nuts optionsl mint
 info

* try to enable mpp with lnd

* test mpp with third payment

tests/conftest.py

@@ -44,6 +44,7 @@ settings.mint_derivation_path_list = []
 settings.mint_private_key = "TEST_PRIVATE_KEY"
 settings.mint_seed_decryption_key = ""
 settings.mint_max_balance = 0
+settings.mint_lnd_enable_mpp = True
 
 assert "test" in settings.cashu_dir
 shutil.rmtree(settings.cashu_dir, ignore_errors=True)

tests/test_mint_init.py

@@ -249,11 +249,11 @@ async def test_startup_regtest_pending_quote_pending(wallet: Wallet, ledger: Led
     invoice_payment_request = str(invoice_dict["payment_request"])
 
     # wallet pays the invoice
-    quote = await wallet.get_pay_amount_with_fees(invoice_payment_request)
+    quote = await wallet.melt_quote(invoice_payment_request)
     total_amount = quote.amount + quote.fee_reserve
     _, send_proofs = await wallet.split_to_send(wallet.proofs, total_amount)
     asyncio.create_task(
-        wallet.pay_lightning(
+        wallet.melt(
             proofs=send_proofs,
             invoice=invoice_payment_request,
             fee_reserve_sat=quote.fee_reserve,
@@ -294,11 +294,11 @@ async def test_startup_regtest_pending_quote_success(wallet: Wallet, ledger: Led
     invoice_payment_request = str(invoice_dict["payment_request"])
 
     # wallet pays the invoice
-    quote = await wallet.get_pay_amount_with_fees(invoice_payment_request)
+    quote = await wallet.melt_quote(invoice_payment_request)
     total_amount = quote.amount + quote.fee_reserve
     _, send_proofs = await wallet.split_to_send(wallet.proofs, total_amount)
     asyncio.create_task(
-        wallet.pay_lightning(
+        wallet.melt(
             proofs=send_proofs,
             invoice=invoice_payment_request,
             fee_reserve_sat=quote.fee_reserve,
@@ -344,11 +344,11 @@ async def test_startup_regtest_pending_quote_failure(wallet: Wallet, ledger: Led
     preimage_hash = invoice_obj.payment_hash
 
     # wallet pays the invoice
-    quote = await wallet.get_pay_amount_with_fees(invoice_payment_request)
+    quote = await wallet.melt_quote(invoice_payment_request)
     total_amount = quote.amount + quote.fee_reserve
     _, send_proofs = await wallet.split_to_send(wallet.proofs, total_amount)
     asyncio.create_task(
-        wallet.pay_lightning(
+        wallet.melt(
             proofs=send_proofs,
             invoice=invoice_payment_request,
             fee_reserve_sat=quote.fee_reserve,

tests/test_mint_lightning_blink.py

@@ -2,7 +2,7 @@ import pytest
 import respx
 from httpx import Response
 
-from cashu.core.base import Amount, MeltQuote, Unit
+from cashu.core.base import Amount, MeltQuote, PostMeltQuoteRequest, Unit
 from cashu.core.settings import settings
 from cashu.lightning.blink import MINIMUM_FEE_MSAT, BlinkWallet  # type: ignore
 
@@ -192,7 +192,10 @@ async def test_blink_get_payment_quote():
     # response says 1 sat fees but invoice (1000 sat) * 0.5% is 5 sat so we expect 5 sat
     mock_response = {"data": {"lnInvoiceFeeProbe": {"amount": 1}}}
     respx.post(blink.endpoint).mock(return_value=Response(200, json=mock_response))
-    quote = await blink.get_payment_quote(payment_request)
+    melt_quote_request = PostMeltQuoteRequest(
+        unit=Unit.sat.name, request=payment_request
+    )
+    quote = await blink.get_payment_quote(melt_quote_request)
     assert quote.checking_id == payment_request
     assert quote.amount == Amount(Unit.sat, 1000)  # sat
     assert quote.fee == Amount(Unit.sat, 5)  # sat
@@ -200,7 +203,10 @@ async def test_blink_get_payment_quote():
     # response says 10 sat fees but invoice (1000 sat) * 0.5% is 5 sat so we expect 10 sat
     mock_response = {"data": {"lnInvoiceFeeProbe": {"amount": 10}}}
     respx.post(blink.endpoint).mock(return_value=Response(200, json=mock_response))
-    quote = await blink.get_payment_quote(payment_request)
+    melt_quote_request = PostMeltQuoteRequest(
+        unit=Unit.sat.name, request=payment_request
+    )
+    quote = await blink.get_payment_quote(melt_quote_request)
     assert quote.checking_id == payment_request
     assert quote.amount == Amount(Unit.sat, 1000)  # sat
     assert quote.fee == Amount(Unit.sat, 10)  # sat
@@ -208,7 +214,10 @@ async def test_blink_get_payment_quote():
     # response says 10 sat fees but invoice (4973 sat) * 0.5% is 24.865 sat so we expect 25 sat
     mock_response = {"data": {"lnInvoiceFeeProbe": {"amount": 10}}}
     respx.post(blink.endpoint).mock(return_value=Response(200, json=mock_response))
-    quote = await blink.get_payment_quote(payment_request_4973)
+    melt_quote_request_4973 = PostMeltQuoteRequest(
+        unit=Unit.sat.name, request=payment_request_4973
+    )
+    quote = await blink.get_payment_quote(melt_quote_request_4973)
     assert quote.checking_id == payment_request_4973
     assert quote.amount == Amount(Unit.sat, 4973)  # sat
     assert quote.fee == Amount(Unit.sat, 25)  # sat
@@ -216,7 +225,10 @@ async def test_blink_get_payment_quote():
     # response says 0 sat fees but invoice (1 sat) * 0.5% is 0.005 sat so we expect MINIMUM_FEE_MSAT/1000 sat
     mock_response = {"data": {"lnInvoiceFeeProbe": {"amount": 0}}}
     respx.post(blink.endpoint).mock(return_value=Response(200, json=mock_response))
-    quote = await blink.get_payment_quote(payment_request_1)
+    melt_quote_request_1 = PostMeltQuoteRequest(
+        unit=Unit.sat.name, request=payment_request_1
+    )
+    quote = await blink.get_payment_quote(melt_quote_request_1)
     assert quote.checking_id == payment_request_1
     assert quote.amount == Amount(Unit.sat, 1)  # sat
     assert quote.fee == Amount(Unit.sat, MINIMUM_FEE_MSAT // 1000)  # msat
@@ -228,7 +240,10 @@ async def test_blink_get_payment_quote_backend_error():
     # response says error but invoice (1000 sat) * 0.5% is 5 sat so we expect 10 sat
     mock_response = {"data": {"lnInvoiceFeeProbe": {"errors": [{"message": "error"}]}}}
     respx.post(blink.endpoint).mock(return_value=Response(200, json=mock_response))
-    quote = await blink.get_payment_quote(payment_request)
+    melt_quote_request = PostMeltQuoteRequest(
+        unit=Unit.sat.name, request=payment_request
+    )
+    quote = await blink.get_payment_quote(melt_quote_request)
     assert quote.checking_id == payment_request
     assert quote.amount == Amount(Unit.sat, 1000)  # sat
     assert quote.fee == Amount(Unit.sat, 5)  # sat

tests/test_mint_operations.py

@@ -73,7 +73,7 @@ async def test_melt_external(wallet1: Wallet, ledger: Ledger):
     invoice_dict = get_real_invoice(64)
     invoice_payment_request = invoice_dict["payment_request"]
 
-    mint_quote = await wallet1.get_pay_amount_with_fees(invoice_payment_request)
+    mint_quote = await wallet1.melt_quote(invoice_payment_request)
     total_amount = mint_quote.amount + mint_quote.fee_reserve
     keep_proofs, send_proofs = await wallet1.split_to_send(wallet1.proofs, total_amount)
     melt_quote = await ledger.melt_quote(

tests/test_mint_regtest.py

@@ -41,12 +41,12 @@ async def test_regtest_pending_quote(wallet: Wallet, ledger: Ledger):
     invoice_payment_request = str(invoice_dict["payment_request"])
 
     # wallet pays the invoice
-    quote = await wallet.get_pay_amount_with_fees(invoice_payment_request)
+    quote = await wallet.melt_quote(invoice_payment_request)
     total_amount = quote.amount + quote.fee_reserve
     _, send_proofs = await wallet.split_to_send(wallet.proofs, total_amount)
     asyncio.create_task(ledger.melt(proofs=send_proofs, quote=quote.quote))
     # asyncio.create_task(
-    #     wallet.pay_lightning(
+    #     wallet.melt(
     #         proofs=send_proofs,
     #         invoice=invoice_payment_request,
     #         fee_reserve_sat=quote.fee_reserve,

tests/test_wallet.py

@@ -271,7 +271,7 @@ async def test_melt(wallet1: Wallet):
         invoice_payment_hash = str(invoice.payment_hash)
         invoice_payment_request = invoice.bolt11
 
-    quote = await wallet1.get_pay_amount_with_fees(invoice_payment_request)
+    quote = await wallet1.request_melt(invoice_payment_request)
     total_amount = quote.amount + quote.fee_reserve
 
     if is_regtest:
@@ -285,7 +285,7 @@ async def test_melt(wallet1: Wallet):
 
     _, send_proofs = await wallet1.split_to_send(wallet1.proofs, total_amount)
 
-    melt_response = await wallet1.pay_lightning(
+    melt_response = await wallet1.melt(
         proofs=send_proofs,
         invoice=invoice_payment_request,
         fee_reserve_sat=quote.fee_reserve,

tests/test_wallet_regtest.py

@@ -43,11 +43,11 @@ async def test_regtest_pending_quote(wallet: Wallet, ledger: Ledger):
     invoice_payment_request = str(invoice_dict["payment_request"])
 
     # wallet pays the invoice
-    quote = await wallet.get_pay_amount_with_fees(invoice_payment_request)
+    quote = await wallet.melt_quote(invoice_payment_request)
     total_amount = quote.amount + quote.fee_reserve
     _, send_proofs = await wallet.split_to_send(wallet.proofs, total_amount)
     asyncio.create_task(
-        wallet.pay_lightning(
+        wallet.melt(
             proofs=send_proofs,
             invoice=invoice_payment_request,
             fee_reserve_sat=quote.fee_reserve,
@@ -83,11 +83,11 @@ async def test_regtest_failed_quote(wallet: Wallet, ledger: Ledger):
     preimage_hash = invoice_obj.payment_hash
 
     # wallet pays the invoice
-    quote = await wallet.get_pay_amount_with_fees(invoice_payment_request)
+    quote = await wallet.melt_quote(invoice_payment_request)
     total_amount = quote.amount + quote.fee_reserve
     _, send_proofs = await wallet.split_to_send(wallet.proofs, total_amount)
     asyncio.create_task(
-        wallet.pay_lightning(
+        wallet.melt(
             proofs=send_proofs,
             invoice=invoice_payment_request,
             fee_reserve_sat=quote.fee_reserve,

tests/test_wallet_regtest_mpp.py

@@ -0,0 +1,127 @@
+import asyncio
+from typing import List
+
+import pytest
+import pytest_asyncio
+
+from cashu.core.base import Method, Proof
+from cashu.mint.ledger import Ledger
+from cashu.wallet.wallet import Wallet
+from tests.conftest import SERVER_ENDPOINT
+from tests.helpers import (
+    get_real_invoice,
+    is_fake,
+    pay_if_regtest,
+)
+
+
+@pytest_asyncio.fixture(scope="function")
+async def wallet():
+    wallet = await Wallet.with_db(
+        url=SERVER_ENDPOINT,
+        db="test_data/wallet",
+        name="wallet",
+    )
+    await wallet.load_mint()
+    yield wallet
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(is_fake, reason="only regtest")
+async def test_regtest_pay_mpp(wallet: Wallet, ledger: Ledger):
+    # make sure that mpp is supported by the bolt11-sat backend
+    if not ledger.backends[Method["bolt11"]][wallet.unit].supports_mpp:
+        pytest.skip("backend does not support mpp")
+
+    # make sure wallet knows the backend supports mpp
+    assert wallet.mint_info.supports_mpp("bolt11", wallet.unit)
+
+    # top up wallet twice so we have enough for two payments
+    topup_invoice = await wallet.request_mint(128)
+    pay_if_regtest(topup_invoice.bolt11)
+    proofs1 = await wallet.mint(128, id=topup_invoice.id)
+    assert wallet.balance == 128
+
+    topup_invoice = await wallet.request_mint(128)
+    pay_if_regtest(topup_invoice.bolt11)
+    proofs2 = await wallet.mint(128, id=topup_invoice.id)
+    assert wallet.balance == 256
+
+    # this is the invoice we want to pay in two parts
+    invoice_dict = get_real_invoice(64)
+    invoice_payment_request = invoice_dict["payment_request"]
+
+    async def pay_mpp(amount: int, proofs: List[Proof], delay: float = 0.0):
+        await asyncio.sleep(delay)
+        # wallet pays 32 sat of the invoice
+        quote = await wallet.melt_quote(invoice_payment_request, amount=32)
+        assert quote.amount == amount
+        await wallet.melt(
+            proofs,
+            invoice_payment_request,
+            fee_reserve_sat=quote.fee_reserve,
+            quote_id=quote.quote,
+        )
+
+    # call pay_mpp twice in parallel to pay the full invoice
+    # we delay the second payment so that the wallet doesn't derive the same blindedmessages twice due to a race condition
+    await asyncio.gather(pay_mpp(32, proofs1), pay_mpp(32, proofs2, delay=0.5))
+
+    assert wallet.balance <= 256 - 64
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(is_fake, reason="only regtest")
+async def test_regtest_pay_mpp_incomplete_payment(wallet: Wallet, ledger: Ledger):
+    # make sure that mpp is supported by the bolt11-sat backend
+    if not ledger.backends[Method["bolt11"]][wallet.unit].supports_mpp:
+        pytest.skip("backend does not support mpp")
+
+    # make sure wallet knows the backend supports mpp
+    assert wallet.mint_info.supports_mpp("bolt11", wallet.unit)
+
+    # top up wallet twice so we have enough for three payments
+    topup_invoice = await wallet.request_mint(128)
+    pay_if_regtest(topup_invoice.bolt11)
+    proofs1 = await wallet.mint(128, id=topup_invoice.id)
+    assert wallet.balance == 128
+
+    topup_invoice = await wallet.request_mint(128)
+    pay_if_regtest(topup_invoice.bolt11)
+    proofs2 = await wallet.mint(128, id=topup_invoice.id)
+    assert wallet.balance == 256
+
+    topup_invoice = await wallet.request_mint(128)
+    pay_if_regtest(topup_invoice.bolt11)
+    proofs3 = await wallet.mint(128, id=topup_invoice.id)
+    assert wallet.balance == 384
+
+    # this is the invoice we want to pay in two parts
+    invoice_dict = get_real_invoice(64)
+    invoice_payment_request = invoice_dict["payment_request"]
+
+    async def pay_mpp(amount: int, proofs: List[Proof], delay: float = 0.0):
+        await asyncio.sleep(delay)
+        # wallet pays 32 sat of the invoice
+        quote = await wallet.melt_quote(invoice_payment_request, amount=amount)
+        assert quote.amount == amount
+        await wallet.melt(
+            proofs,
+            invoice_payment_request,
+            fee_reserve_sat=quote.fee_reserve,
+            quote_id=quote.quote,
+        )
+
+    # instead: call pay_mpp twice in the background, sleep for a bit, then check if the payment was successful (it should not be)
+    asyncio.create_task(pay_mpp(32, proofs1))
+    asyncio.create_task(pay_mpp(16, proofs2, delay=0.5))
+    await asyncio.sleep(2)
+
+    # payment is still pending because the full amount has not been paid
+    assert wallet.balance == 384
+
+    # send the remaining 16 sat to complete the payment
+    asyncio.create_task(pay_mpp(16, proofs3, delay=0.5))
+    await asyncio.sleep(2)
+
+    assert wallet.balance <= 384 - 64