From c235f76b245dc61a6ccb784ba9b5382ad9545960 Mon Sep 17 00:00:00 2001 From: callebtc <93376500+callebtc@users.noreply.github.com> Date: Wed, 3 Jun 2026 18:06:05 +0200 Subject: [PATCH 1/3] fix mypy --- tests/lightning/test_fee_unit_regressions.py | 60 +++++++ tests/mint/test_mint_fee_unit_regressions.py | 174 +++++++++++++++++++ 2 files changed, 234 insertions(+) create mode 100644 tests/lightning/test_fee_unit_regressions.py create mode 100644 tests/mint/test_mint_fee_unit_regressions.py diff --git a/tests/lightning/test_fee_unit_regressions.py b/tests/lightning/test_fee_unit_regressions.py new file mode 100644 index 000000000..3d3ff42e2 --- /dev/null +++ b/tests/lightning/test_fee_unit_regressions.py @@ -0,0 +1,60 @@ +from types import SimpleNamespace +from typing import Type + +import pytest + +from cashu.core.base import Amount, MeltQuote, MeltQuoteState, Unit +from cashu.lightning.base import PaymentResponse, PaymentResult +from cashu.lightning.lnd_grpc.lnd_grpc import LndRPCWallet +from cashu.lightning.lndrest import LndRestWallet + + +def _quote(request: str, amount: int, unit: str) -> MeltQuote: + return MeltQuote( + quote="q1", + method="bolt11", + request=request, + checking_id="checking-1", + unit=unit, + amount=amount, + fee_reserve=1, + state=MeltQuoteState.unpaid, + ) + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + ("wallet_cls", "decode_path"), + [ + (LndRPCWallet, "cashu.lightning.lnd_grpc.lnd_grpc.bolt11.decode"), + (LndRestWallet, "cashu.lightning.lndrest.bolt11.decode"), + ], +) +async def test_lnd_mpp_preserves_msat_quote_amount_unit( + monkeypatch: pytest.MonkeyPatch, + wallet_cls: Type[LndRPCWallet] | Type[LndRestWallet], + decode_path: str, +): + wallet = object.__new__(wallet_cls) + wallet.supports_mpp = True + captured: dict[str, Amount | int] = {} + + async def pay_partial_invoice( + quote: MeltQuote, amount: Amount, fee_limit_msat: int + ) -> PaymentResponse: + captured["amount"] = amount + captured["fee_limit_msat"] = fee_limit_msat + return PaymentResponse(result=PaymentResult.SETTLED) + + monkeypatch.setattr(wallet, "pay_partial_invoice", pay_partial_invoice) + monkeypatch.setattr( + decode_path, + lambda request: SimpleNamespace(amount_msat=2_000), + ) + + await wallet.pay_invoice( + _quote("lnbc1fake", amount=1_000, unit="msat"), fee_limit_msat=123 + ) + + assert captured["amount"] == Amount(Unit.msat, 1_000) + assert captured["fee_limit_msat"] == 123 diff --git a/tests/mint/test_mint_fee_unit_regressions.py b/tests/mint/test_mint_fee_unit_regressions.py new file mode 100644 index 000000000..28b79bcc2 --- /dev/null +++ b/tests/mint/test_mint_fee_unit_regressions.py @@ -0,0 +1,174 @@ +import math +from types import SimpleNamespace + +import pytest + +from cashu.core.base import Amount, MeltQuote, MeltQuoteState, Method, Proof, Unit +from cashu.lightning.base import PaymentResponse, PaymentResult, PaymentStatus +from cashu.mint.ledger import Ledger + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + ("unit", "fee_reserve", "expected_fee_limit_msat"), + [ + (Unit.sat, 2, 2_000), + (Unit.msat, 2_000, 2_000), + ], +) +async def test_melt_converts_fee_reserve_to_msat_for_backend_fee_limit( + unit: Unit, fee_reserve: int, expected_fee_limit_msat: int +): + melt_quote = MeltQuote( + quote="q1", + method=Method.bolt11.name, + request="lnbc1fake", + checking_id="checking-1", + unit=unit.name, + amount=10_000, + fee_reserve=fee_reserve, + state=MeltQuoteState.unpaid, + ) + captured = {} + + async def get_melt_quote(quote_id: str) -> MeltQuote: + assert quote_id == melt_quote.quote + return melt_quote + + async def verify_inputs_and_outputs(proofs): + return None + + async def verify_and_set_melt_quote_pending(quote, proofs, keysets): + quote.state = MeltQuoteState.pending + return quote + + async def melt_mint_settle_internally(quote, proofs): + return quote + + async def pay_invoice(quote: MeltQuote, fee_limit_msat: int) -> PaymentResponse: + captured["fee_limit_msat"] = fee_limit_msat + return PaymentResponse( + result=PaymentResult.SETTLED, + checking_id=quote.checking_id, + fee=Amount(Unit.msat, 0), + preimage="00" * 32, + ) + + async def set_melt_quote_paid_and_invalidate_proofs(**kwargs): + return kwargs["quote"] + + ledger = SimpleNamespace( + disable_melt=False, + get_melt_quote=get_melt_quote, + _verify_and_get_unit_method=lambda unit_name, method_name: ( + unit, + Method.bolt11, + ), + _verify_proofs_unit=lambda proofs, expected_unit: None, + _verify_sigall_spending_conditions=lambda proofs, outputs, message: None, + get_fees_for_proofs=lambda proofs: 0, + verify_inputs_and_outputs=verify_inputs_and_outputs, + db_write=SimpleNamespace( + verify_and_set_melt_quote_pending=verify_and_set_melt_quote_pending, + set_melt_quote_paid_and_invalidate_proofs=( + set_melt_quote_paid_and_invalidate_proofs + ), + ), + melt_mint_settle_internally=melt_mint_settle_internally, + backends={ + Method.bolt11: { + unit: SimpleNamespace(pay_invoice=pay_invoice), + }, + }, + keysets={}, + ) + proof = Proof( + id="keyset-id", + amount=melt_quote.amount + melt_quote.fee_reserve, + secret=f"proof-{unit.name}", + C="00", + ) + + await Ledger.melt(ledger, proofs=[proof], quote=melt_quote.quote) # type: ignore[arg-type] # type: ignore[arg-type] # type: ignore[arg-type] + + assert captured["fee_limit_msat"] == expected_fee_limit_msat + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + ("fee_msat", "expected_fee_paid_sat"), + [ + (1000, 1), + (1001, 2), + (1500, 2), + (1999, 2), + (2001, 3), + ], +) +async def test_pending_melt_resolution_fee_paid_rounds_up( + fee_msat: int, expected_fee_paid_sat: int +): + melt_quote = MeltQuote( + quote="q-pending-fee-round", + method=Method.bolt11.name, + request="lnbc1fake", + checking_id="checking-pending", + unit=Unit.sat.name, + amount=100, + fee_reserve=10, + state=MeltQuoteState.pending, + ) + + async def crud_get_melt_quote(quote_id: str, db=None): + return melt_quote + + async def crud_get_mint_quote(request: str, db=None): + return None + + async def crud_get_pending_proofs_for_quote(quote_id: str, db=None): + return [] + + async def crud_get_blinded_messages_melt_id(melt_id: str, db=None): + return None + + async def set_melt_quote_paid_and_invalidate_proofs(**kwargs): + return kwargs["quote"] + + async def get_payment_status(checking_id: str) -> PaymentStatus: + return PaymentStatus( + result=PaymentResult.SETTLED, + fee=Amount(Unit.msat, fee_msat), + preimage="aa" * 32, + ) + + ledger = SimpleNamespace( + crud=SimpleNamespace( + get_melt_quote=crud_get_melt_quote, + get_mint_quote=crud_get_mint_quote, + get_pending_proofs_for_quote=crud_get_pending_proofs_for_quote, + get_blinded_messages_melt_id=crud_get_blinded_messages_melt_id, + ), + db=None, + _verify_and_get_unit_method=lambda unit_name, method_name: ( + Unit.sat, + Method.bolt11, + ), + get_fees_for_proofs=lambda proofs: 0, + db_write=SimpleNamespace( + set_melt_quote_paid_and_invalidate_proofs=( + set_melt_quote_paid_and_invalidate_proofs + ), + ), + backends={ + Method.bolt11: { + Unit.sat: SimpleNamespace(get_payment_status=get_payment_status), + }, + }, + keysets={}, + ) + + result = await Ledger.get_melt_quote(ledger, quote_id=melt_quote.quote) # type: ignore[arg-type] # type: ignore[arg-type] # type: ignore[arg-type] + + assert result.state == MeltQuoteState.paid + assert result.fee_paid == expected_fee_paid_sat + assert result.fee_paid == math.ceil(fee_msat / 1000) From 81f2fd9775aeed023c9cca2d8c2cc7fc592dab46 Mon Sep 17 00:00:00 2001 From: callebtc <93376500+callebtc@users.noreply.github.com> Date: Wed, 3 Jun 2026 18:28:35 +0200 Subject: [PATCH 2/3] fix npm --- tests/mint/test_mint_fee_unit_regressions.py | 174 ------------------- tests/mint/test_mint_melt.py | 100 ++++++++--- 2 files changed, 76 insertions(+), 198 deletions(-) delete mode 100644 tests/mint/test_mint_fee_unit_regressions.py diff --git a/tests/mint/test_mint_fee_unit_regressions.py b/tests/mint/test_mint_fee_unit_regressions.py deleted file mode 100644 index 28b79bcc2..000000000 --- a/tests/mint/test_mint_fee_unit_regressions.py +++ /dev/null @@ -1,174 +0,0 @@ -import math -from types import SimpleNamespace - -import pytest - -from cashu.core.base import Amount, MeltQuote, MeltQuoteState, Method, Proof, Unit -from cashu.lightning.base import PaymentResponse, PaymentResult, PaymentStatus -from cashu.mint.ledger import Ledger - - -@pytest.mark.asyncio -@pytest.mark.parametrize( - ("unit", "fee_reserve", "expected_fee_limit_msat"), - [ - (Unit.sat, 2, 2_000), - (Unit.msat, 2_000, 2_000), - ], -) -async def test_melt_converts_fee_reserve_to_msat_for_backend_fee_limit( - unit: Unit, fee_reserve: int, expected_fee_limit_msat: int -): - melt_quote = MeltQuote( - quote="q1", - method=Method.bolt11.name, - request="lnbc1fake", - checking_id="checking-1", - unit=unit.name, - amount=10_000, - fee_reserve=fee_reserve, - state=MeltQuoteState.unpaid, - ) - captured = {} - - async def get_melt_quote(quote_id: str) -> MeltQuote: - assert quote_id == melt_quote.quote - return melt_quote - - async def verify_inputs_and_outputs(proofs): - return None - - async def verify_and_set_melt_quote_pending(quote, proofs, keysets): - quote.state = MeltQuoteState.pending - return quote - - async def melt_mint_settle_internally(quote, proofs): - return quote - - async def pay_invoice(quote: MeltQuote, fee_limit_msat: int) -> PaymentResponse: - captured["fee_limit_msat"] = fee_limit_msat - return PaymentResponse( - result=PaymentResult.SETTLED, - checking_id=quote.checking_id, - fee=Amount(Unit.msat, 0), - preimage="00" * 32, - ) - - async def set_melt_quote_paid_and_invalidate_proofs(**kwargs): - return kwargs["quote"] - - ledger = SimpleNamespace( - disable_melt=False, - get_melt_quote=get_melt_quote, - _verify_and_get_unit_method=lambda unit_name, method_name: ( - unit, - Method.bolt11, - ), - _verify_proofs_unit=lambda proofs, expected_unit: None, - _verify_sigall_spending_conditions=lambda proofs, outputs, message: None, - get_fees_for_proofs=lambda proofs: 0, - verify_inputs_and_outputs=verify_inputs_and_outputs, - db_write=SimpleNamespace( - verify_and_set_melt_quote_pending=verify_and_set_melt_quote_pending, - set_melt_quote_paid_and_invalidate_proofs=( - set_melt_quote_paid_and_invalidate_proofs - ), - ), - melt_mint_settle_internally=melt_mint_settle_internally, - backends={ - Method.bolt11: { - unit: SimpleNamespace(pay_invoice=pay_invoice), - }, - }, - keysets={}, - ) - proof = Proof( - id="keyset-id", - amount=melt_quote.amount + melt_quote.fee_reserve, - secret=f"proof-{unit.name}", - C="00", - ) - - await Ledger.melt(ledger, proofs=[proof], quote=melt_quote.quote) # type: ignore[arg-type] # type: ignore[arg-type] # type: ignore[arg-type] - - assert captured["fee_limit_msat"] == expected_fee_limit_msat - - -@pytest.mark.asyncio -@pytest.mark.parametrize( - ("fee_msat", "expected_fee_paid_sat"), - [ - (1000, 1), - (1001, 2), - (1500, 2), - (1999, 2), - (2001, 3), - ], -) -async def test_pending_melt_resolution_fee_paid_rounds_up( - fee_msat: int, expected_fee_paid_sat: int -): - melt_quote = MeltQuote( - quote="q-pending-fee-round", - method=Method.bolt11.name, - request="lnbc1fake", - checking_id="checking-pending", - unit=Unit.sat.name, - amount=100, - fee_reserve=10, - state=MeltQuoteState.pending, - ) - - async def crud_get_melt_quote(quote_id: str, db=None): - return melt_quote - - async def crud_get_mint_quote(request: str, db=None): - return None - - async def crud_get_pending_proofs_for_quote(quote_id: str, db=None): - return [] - - async def crud_get_blinded_messages_melt_id(melt_id: str, db=None): - return None - - async def set_melt_quote_paid_and_invalidate_proofs(**kwargs): - return kwargs["quote"] - - async def get_payment_status(checking_id: str) -> PaymentStatus: - return PaymentStatus( - result=PaymentResult.SETTLED, - fee=Amount(Unit.msat, fee_msat), - preimage="aa" * 32, - ) - - ledger = SimpleNamespace( - crud=SimpleNamespace( - get_melt_quote=crud_get_melt_quote, - get_mint_quote=crud_get_mint_quote, - get_pending_proofs_for_quote=crud_get_pending_proofs_for_quote, - get_blinded_messages_melt_id=crud_get_blinded_messages_melt_id, - ), - db=None, - _verify_and_get_unit_method=lambda unit_name, method_name: ( - Unit.sat, - Method.bolt11, - ), - get_fees_for_proofs=lambda proofs: 0, - db_write=SimpleNamespace( - set_melt_quote_paid_and_invalidate_proofs=( - set_melt_quote_paid_and_invalidate_proofs - ), - ), - backends={ - Method.bolt11: { - Unit.sat: SimpleNamespace(get_payment_status=get_payment_status), - }, - }, - keysets={}, - ) - - result = await Ledger.get_melt_quote(ledger, quote_id=melt_quote.quote) # type: ignore[arg-type] # type: ignore[arg-type] # type: ignore[arg-type] - - assert result.state == MeltQuoteState.paid - assert result.fee_paid == expected_fee_paid_sat - assert result.fee_paid == math.ceil(fee_msat / 1000) diff --git a/tests/mint/test_mint_melt.py b/tests/mint/test_mint_melt.py index a557fd63c..acaabd84e 100644 --- a/tests/mint/test_mint_melt.py +++ b/tests/mint/test_mint_melt.py @@ -3,7 +3,15 @@ import pytest import pytest_asyncio -from cashu.core.base import MeltQuote, MeltQuoteState, MintQuoteState, Proof +from cashu.core.base import ( + Amount, + MeltQuote, + MeltQuoteState, + Method, + MintQuoteState, + Proof, + Unit, +) from cashu.core.errors import ( LightningPaymentFailedError, OutputsAlreadySignedError, @@ -11,7 +19,7 @@ ) from cashu.core.models import PostMeltQuoteRequest, PostMintQuoteRequest from cashu.core.settings import settings -from cashu.lightning.base import PaymentResult +from cashu.lightning.base import PaymentResult, PaymentStatus from cashu.mint.ledger import Ledger from cashu.wallet.wallet import Wallet from tests.conftest import SERVER_ENDPOINT @@ -776,6 +784,7 @@ async def test_mint_pay_with_duplicate_checking_id(wallet): "Melt quote already paid or pending.", ) + @pytest.mark.asyncio @pytest.mark.skipif(is_deprecated_api_only, reason="Can't run on the deprecated API") async def test_melt_race_condition_fixed(wallet: Wallet, ledger: Ledger): @@ -793,7 +802,11 @@ async def test_melt_race_condition_fixed(wallet: Wallet, ledger: Ledger): proofs2 = await wallet.mint(128, quote_id=mq2.quote) # Invoice for 64 sats (+2 fee = 66 sats needed) - invoice = get_real_invoice(64)["payment_request"] if is_regtest else "lnbcrt640n1pn0r3tfpp5e30xac756gvd26cn3tgsh8ug6ct555zrvl7vsnma5cwp4g7auq5qdqqcqzzsxqyz5vqsp5xfhtzg0y3mekv6nsdnj43c346smh036t4f8gcfa2zwpxzwcryqvs9qxpqysgqw5juev8y3zxpdu0mvdrced5c6a852f9x7uh57g6fgjgcg5muqzd5474d7xgh770frazel67eejfwelnyr507q46hxqehala880rhlqspw07ta0" + invoice = ( + get_real_invoice(64)["payment_request"] + if is_regtest + else "lnbcrt640n1pn0r3tfpp5e30xac756gvd26cn3tgsh8ug6ct555zrvl7vsnma5cwp4g7auq5qdqqcqzzsxqyz5vqsp5xfhtzg0y3mekv6nsdnj43c346smh036t4f8gcfa2zwpxzwcryqvs9qxpqysgqw5juev8y3zxpdu0mvdrced5c6a852f9x7uh57g6fgjgcg5muqzd5474d7xgh770frazel67eejfwelnyr507q46hxqehala880rhlqspw07ta0" + ) melt_quote1 = await wallet.melt_quote(invoice) melt_quote2 = await wallet.melt_quote(invoice) @@ -802,7 +815,7 @@ async def test_melt_race_condition_fixed(wallet: Wallet, ledger: Ledger): responses = await asyncio.gather( ledger.melt(proofs=proofs1, quote=melt_quote1.quote), ledger.melt(proofs=proofs2, quote=melt_quote2.quote), - return_exceptions=True + return_exceptions=True, ) failures = [r for r in responses if isinstance(r, Exception)] @@ -817,7 +830,9 @@ async def test_melt_race_condition_fixed(wallet: Wallet, ledger: Ledger): states = await ledger.db_read.get_proofs_states([p.Y for p in failed_proofs]) # We expect them to NOT be pending if the bug is fixed - assert not any(s.pending for s in states), "Proofs from failed melt request stuck in pending!" + assert not any(s.pending for s in states), ( + "Proofs from failed melt request stuck in pending!" + ) @pytest.mark.asyncio @@ -832,33 +847,30 @@ async def test_melt_with_wrong_unit_proofs(ledger: Ledger, wallet: Wallet): unit="usd", ) await wallet_usd.load_mint() - + mint_quote_usd = await wallet_usd.request_mint(100) await pay_if_regtest(mint_quote_usd.request) usd_proofs = await wallet_usd.mint(100, quote_id=mint_quote_usd.quote) assert wallet_usd.unit.name == "usd" - + sat_mint_quote = await ledger.mint_quote( quote_request=PostMintQuoteRequest(amount=100, unit="sat") ) sat_invoice = sat_mint_quote.request - + sat_melt_quote = await ledger.melt_quote( PostMeltQuoteRequest(unit="sat", request=sat_invoice) ) - + assert sat_melt_quote.amount == 100 assert sat_melt_quote.unit == "sat" - + await assert_err( - ledger.melt( - proofs=usd_proofs, - quote=sat_melt_quote.quote, - outputs=[] - ), - "proof unit usd does not match quote unit sat" + ledger.melt(proofs=usd_proofs, quote=sat_melt_quote.quote, outputs=[]), + "proof unit usd does not match quote unit sat", ) + @pytest.mark.asyncio async def test_internal_melt_failure_unsets_pending(ledger: Ledger, wallet: Wallet): """ @@ -869,34 +881,74 @@ async def test_internal_melt_failure_unsets_pending(ledger: Ledger, wallet: Wall mint_quote_req = await wallet.request_mint(64) await pay_if_regtest(mint_quote_req.request) proofs = await wallet.mint(64, quote_id=mint_quote_req.quote) - + # Create internal mint quote sat_mint_quote = await ledger.mint_quote( quote_request=PostMintQuoteRequest(amount=64, unit="sat") ) - + # Create internal melt quote for the same invoice sat_melt_quote = await ledger.melt_quote( PostMeltQuoteRequest(unit="sat", request=sat_mint_quote.request) ) - + # Make the mint quote "paid" to cause melt_mint_settle_internally to fail sat_mint_quote.state = MintQuoteState.paid await ledger.crud.update_mint_quote(quote=sat_mint_quote, db=ledger.db) - + # Try to melt - it should fail because mint quote is already paid await assert_err( ledger.melt(proofs=proofs, quote=sat_melt_quote.quote, outputs=[]), - "mint quote already paid" + "mint quote already paid", ) - + # Check that proofs are not pending states = await ledger.db_read.get_proofs_states([p.Y for p in proofs]) assert not any(s.pending for s in states), "Proofs stuck in pending!" - + # Check that quote is not pending and is unpaid - melt_quote = await ledger.crud.get_melt_quote(quote_id=sat_melt_quote.quote, db=ledger.db) + melt_quote = await ledger.crud.get_melt_quote( + quote_id=sat_melt_quote.quote, db=ledger.db + ) assert melt_quote is not None assert melt_quote.state == MeltQuoteState.unpaid, "Quote state should be unpaid" assert not melt_quote.pending, "Quote should not be pending" + +@pytest.mark.asyncio +@pytest.mark.skipif(is_regtest, reason="only fake wallet") +async def test_pending_melt_resolution_fee_paid_rounds_up(ledger: Ledger): + test_cases = [ + (1001, 2), + (1500, 2), + (2001, 3), + ] + + for fee_msat, expected_fee_paid_sat in test_cases: + pending_proof, quote = await create_pending_melts( + ledger, check_id=f"check-{fee_msat}" + ) + + async def patched_get_payment_status( + checking_id: str, _fee=fee_msat + ) -> PaymentStatus: + return PaymentStatus( + result=PaymentResult.SETTLED, + fee=Amount(Unit.msat, _fee), + preimage="aa" * 32, + ) + + original = ledger.backends[Method.bolt11][Unit.sat].get_payment_status + ledger.backends[Method.bolt11][ + Unit.sat + ].get_payment_status = patched_get_payment_status # type: ignore[method-assign] + + try: + result = await ledger.get_melt_quote(quote_id=quote.quote) + assert result.state == MeltQuoteState.paid, f"fee_msat={fee_msat}" + assert result.fee_paid == expected_fee_paid_sat, ( + f"fee_msat={fee_msat}, expected={expected_fee_paid_sat}," + f" got={result.fee_paid}" + ) + finally: + ledger.backends[Method.bolt11][Unit.sat].get_payment_status = original # type: ignore[method-assign] From 68273c7553f15eb163c62d686cc480a8ac4e76df Mon Sep 17 00:00:00 2001 From: callebtc <93376500+callebtc@users.noreply.github.com> Date: Sun, 7 Jun 2026 15:17:03 +0200 Subject: [PATCH 3/3] fix test --- tests/mint/test_mint_melt.py | 47 ++---------------------------------- 1 file changed, 2 insertions(+), 45 deletions(-) diff --git a/tests/mint/test_mint_melt.py b/tests/mint/test_mint_melt.py index acaabd84e..315127950 100644 --- a/tests/mint/test_mint_melt.py +++ b/tests/mint/test_mint_melt.py @@ -4,13 +4,10 @@ import pytest_asyncio from cashu.core.base import ( - Amount, MeltQuote, MeltQuoteState, - Method, MintQuoteState, Proof, - Unit, ) from cashu.core.errors import ( LightningPaymentFailedError, @@ -19,7 +16,7 @@ ) from cashu.core.models import PostMeltQuoteRequest, PostMintQuoteRequest from cashu.core.settings import settings -from cashu.lightning.base import PaymentResult, PaymentStatus +from cashu.lightning.base import PaymentResult from cashu.mint.ledger import Ledger from cashu.wallet.wallet import Wallet from tests.conftest import SERVER_ENDPOINT @@ -64,12 +61,11 @@ async def wallet(ledger: Ledger): async def create_pending_melts( - ledger: Ledger, check_id: str = "checking_id" + ledger: Ledger, check_id: str = "checking_id", quote_id: str = "quote_id" ) -> Tuple[Proof, MeltQuote]: """Helper function for startup tests for fakewallet. Creates fake pending melt quote and fake proofs that are in the pending table that look like they're being used to pay the pending melt quote.""" - quote_id = "quote_id" quote = MeltQuote( quote=quote_id, method="bolt11", @@ -913,42 +909,3 @@ async def test_internal_melt_failure_unsets_pending(ledger: Ledger, wallet: Wall assert melt_quote is not None assert melt_quote.state == MeltQuoteState.unpaid, "Quote state should be unpaid" assert not melt_quote.pending, "Quote should not be pending" - - -@pytest.mark.asyncio -@pytest.mark.skipif(is_regtest, reason="only fake wallet") -async def test_pending_melt_resolution_fee_paid_rounds_up(ledger: Ledger): - test_cases = [ - (1001, 2), - (1500, 2), - (2001, 3), - ] - - for fee_msat, expected_fee_paid_sat in test_cases: - pending_proof, quote = await create_pending_melts( - ledger, check_id=f"check-{fee_msat}" - ) - - async def patched_get_payment_status( - checking_id: str, _fee=fee_msat - ) -> PaymentStatus: - return PaymentStatus( - result=PaymentResult.SETTLED, - fee=Amount(Unit.msat, _fee), - preimage="aa" * 32, - ) - - original = ledger.backends[Method.bolt11][Unit.sat].get_payment_status - ledger.backends[Method.bolt11][ - Unit.sat - ].get_payment_status = patched_get_payment_status # type: ignore[method-assign] - - try: - result = await ledger.get_melt_quote(quote_id=quote.quote) - assert result.state == MeltQuoteState.paid, f"fee_msat={fee_msat}" - assert result.fee_paid == expected_fee_paid_sat, ( - f"fee_msat={fee_msat}, expected={expected_fee_paid_sat}," - f" got={result.fee_paid}" - ) - finally: - ledger.backends[Method.bolt11][Unit.sat].get_payment_status = original # type: ignore[method-assign]