mirror of
https://github.com/aljazceru/nutshell.git
synced 2025-12-21 19:14:19 +01:00
38bdb9ce76
* split wallet test from mint test pipeline * regtest mint and wallet * fix * fix * move mint tests * real invoice in regtest mpp
294 lines
9.6 KiB
Python
294 lines
9.6 KiB
Python
import asyncio
|
|
|
|
import bolt11
|
|
import pytest
|
|
import pytest_asyncio
|
|
|
|
from cashu.mint.ledger import Ledger
|
|
from cashu.wallet.crud import get_proofs
|
|
from cashu.wallet.wallet import Wallet
|
|
from tests.conftest import SERVER_ENDPOINT
|
|
from tests.helpers import (
|
|
SLEEP_TIME,
|
|
cancel_invoice,
|
|
get_hold_invoice,
|
|
is_fake,
|
|
pay_if_regtest,
|
|
settle_invoice,
|
|
)
|
|
|
|
|
|
@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_pending_quote(wallet: Wallet, ledger: Ledger):
|
|
# fill wallet
|
|
mint_quote = await wallet.request_mint(64)
|
|
await pay_if_regtest(mint_quote.request)
|
|
await wallet.mint(64, quote_id=mint_quote.quote)
|
|
assert wallet.balance == 64
|
|
|
|
# create hodl invoice
|
|
preimage, invoice_dict = get_hold_invoice(16)
|
|
invoice_payment_request = str(invoice_dict["payment_request"])
|
|
|
|
# wallet pays the invoice
|
|
quote = await wallet.melt_quote(invoice_payment_request)
|
|
total_amount = quote.amount + quote.fee_reserve
|
|
_, send_proofs = await wallet.swap_to_send(wallet.proofs, total_amount)
|
|
asyncio.create_task(
|
|
wallet.melt(
|
|
proofs=send_proofs,
|
|
invoice=invoice_payment_request,
|
|
fee_reserve_sat=quote.fee_reserve,
|
|
quote_id=quote.quote,
|
|
)
|
|
)
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
|
|
states = await wallet.check_proof_state(send_proofs)
|
|
assert all([s.pending for s in states.states])
|
|
|
|
settle_invoice(preimage=preimage)
|
|
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
|
|
states = await wallet.check_proof_state(send_proofs)
|
|
assert all([s.spent for s in states.states])
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.skipif(is_fake, reason="only regtest")
|
|
async def test_regtest_failed_quote(wallet: Wallet, ledger: Ledger):
|
|
# fill wallet
|
|
mint_quote = await wallet.request_mint(64)
|
|
await pay_if_regtest(mint_quote.request)
|
|
await wallet.mint(64, quote_id=mint_quote.quote)
|
|
assert wallet.balance == 64
|
|
|
|
# create hodl invoice
|
|
preimage, invoice_dict = get_hold_invoice(16)
|
|
invoice_payment_request = str(invoice_dict["payment_request"])
|
|
invoice_obj = bolt11.decode(invoice_payment_request)
|
|
preimage_hash = invoice_obj.payment_hash
|
|
|
|
# wallet pays the invoice
|
|
quote = await wallet.melt_quote(invoice_payment_request)
|
|
total_amount = quote.amount + quote.fee_reserve
|
|
_, send_proofs = await wallet.swap_to_send(wallet.proofs, total_amount)
|
|
asyncio.create_task(
|
|
wallet.melt(
|
|
proofs=send_proofs,
|
|
invoice=invoice_payment_request,
|
|
fee_reserve_sat=quote.fee_reserve,
|
|
quote_id=quote.quote,
|
|
)
|
|
)
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
|
|
states = await wallet.check_proof_state(send_proofs)
|
|
assert all([s.pending for s in states.states])
|
|
|
|
cancel_invoice(preimage_hash=preimage_hash)
|
|
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
|
|
states = await wallet.check_proof_state(send_proofs)
|
|
assert all([s.unspent for s in states.states])
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.skipif(is_fake, reason="only regtest")
|
|
async def test_regtest_get_melt_quote_melt_fail_restore_pending_batch_check(
|
|
wallet: Wallet, ledger: Ledger
|
|
):
|
|
# simulates a payment that fails on the mint and whether the wallet is able to
|
|
# restore the state of all proofs (set unreserved)
|
|
mint_quote = await wallet.request_mint(64)
|
|
await pay_if_regtest(mint_quote.request)
|
|
await wallet.mint(64, quote_id=mint_quote.quote)
|
|
assert wallet.balance == 64
|
|
|
|
# create hodl invoice
|
|
preimage, invoice_dict = get_hold_invoice(16)
|
|
invoice_payment_request = str(invoice_dict["payment_request"])
|
|
invoice_obj = bolt11.decode(invoice_payment_request)
|
|
preimage_hash = invoice_obj.payment_hash
|
|
|
|
# wallet pays the invoice
|
|
quote = await wallet.melt_quote(invoice_payment_request)
|
|
total_amount = quote.amount + quote.fee_reserve
|
|
_, send_proofs = await wallet.swap_to_send(
|
|
wallet.proofs, total_amount, set_reserved=True
|
|
)
|
|
|
|
# verify that the proofs are reserved
|
|
proofs_db = await get_proofs(db=wallet.db, melt_id=quote.quote)
|
|
assert all([p.reserved for p in proofs_db])
|
|
|
|
asyncio.create_task(
|
|
wallet.melt(
|
|
proofs=send_proofs,
|
|
invoice=invoice_payment_request,
|
|
fee_reserve_sat=quote.fee_reserve,
|
|
quote_id=quote.quote,
|
|
)
|
|
)
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
|
|
states = await wallet.check_proof_state(send_proofs)
|
|
assert all([s.pending for s in states.states])
|
|
|
|
# fail the payment, melt will unset the proofs as reserved
|
|
cancel_invoice(preimage_hash=preimage_hash)
|
|
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
|
|
# test get_spent_proofs_check_states_batched: verify that no proofs are spent
|
|
spent_proofs = await wallet.get_spent_proofs_check_states_batched(send_proofs)
|
|
assert len(spent_proofs) == 0
|
|
|
|
proofs_db_later = await get_proofs(db=wallet.db, melt_id=quote.quote)
|
|
assert all([p.reserved is False for p in proofs_db_later])
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.skipif(is_fake, reason="only regtest")
|
|
async def test_regtest_get_melt_quote_wallet_crash_melt_fail_restore_pending_batch_check(
|
|
wallet: Wallet, ledger: Ledger
|
|
):
|
|
# simulates a payment failure but the wallet crashed, we confirm that wallet.get_melt_quote() will correctly
|
|
# recover the state of the proofs and set them as unreserved
|
|
mint_quote = await wallet.request_mint(64)
|
|
await pay_if_regtest(mint_quote.request)
|
|
await wallet.mint(64, quote_id=mint_quote.quote)
|
|
assert wallet.balance == 64
|
|
|
|
# create hodl invoice
|
|
preimage, invoice_dict = get_hold_invoice(16)
|
|
invoice_payment_request = str(invoice_dict["payment_request"])
|
|
invoice_obj = bolt11.decode(invoice_payment_request)
|
|
preimage_hash = invoice_obj.payment_hash
|
|
|
|
# wallet pays the invoice
|
|
quote = await wallet.melt_quote(invoice_payment_request)
|
|
total_amount = quote.amount + quote.fee_reserve
|
|
_, send_proofs = await wallet.swap_to_send(
|
|
wallet.proofs, total_amount, set_reserved=True
|
|
)
|
|
assert len(send_proofs) == 2
|
|
|
|
task = asyncio.create_task(
|
|
wallet.melt(
|
|
proofs=send_proofs,
|
|
invoice=invoice_payment_request,
|
|
fee_reserve_sat=quote.fee_reserve,
|
|
quote_id=quote.quote,
|
|
)
|
|
)
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
|
|
# verify that the proofs are reserved
|
|
proofs_db = await get_proofs(db=wallet.db, melt_id=quote.quote)
|
|
assert len(proofs_db) == 2
|
|
assert all([p.reserved for p in proofs_db])
|
|
|
|
# simulate a and kill the task
|
|
task.cancel()
|
|
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
|
|
states = await wallet.check_proof_state(send_proofs)
|
|
assert all([s.pending for s in states.states])
|
|
|
|
# fail the payment, melt will unset the proofs as reserved
|
|
cancel_invoice(preimage_hash=preimage_hash)
|
|
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
|
|
# get the melt quote, this should restore the state of the proofs
|
|
melt_quote = await wallet.get_melt_quote(quote.quote)
|
|
assert melt_quote
|
|
assert melt_quote.unpaid
|
|
|
|
# verify that get_melt_quote unset all proofs as not pending anymore
|
|
proofs_db_later = await get_proofs(db=wallet.db, melt_id=quote.quote)
|
|
assert len(proofs_db_later) == 0
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.skipif(is_fake, reason="only regtest")
|
|
async def test_regtest_wallet_crash_melt_succeed_restore_pending_batch_check(
|
|
wallet: Wallet, ledger: Ledger
|
|
):
|
|
# simulates a payment that succeeds but the wallet crashes in the mean time
|
|
# we then call get_spent_proofs_check_states_batched to check the proof states
|
|
# and the wallet should then invalidate the reserved proofs
|
|
|
|
mint_quote = await wallet.request_mint(64)
|
|
await pay_if_regtest(mint_quote.request)
|
|
await wallet.mint(64, quote_id=mint_quote.quote)
|
|
assert wallet.balance == 64
|
|
|
|
# create hodl invoice
|
|
preimage, invoice_dict = get_hold_invoice(16)
|
|
invoice_payment_request = str(invoice_dict["payment_request"])
|
|
# invoice_obj = bolt11.decode(invoice_payment_request)
|
|
# preimage_hash = invoice_obj.payment_hash
|
|
|
|
# wallet pays the invoice
|
|
quote = await wallet.melt_quote(invoice_payment_request)
|
|
total_amount = quote.amount + quote.fee_reserve
|
|
_, send_proofs = await wallet.swap_to_send(
|
|
wallet.proofs, total_amount, set_reserved=True
|
|
)
|
|
|
|
# verify that the proofs are reserved
|
|
proofs_db = await get_proofs(db=wallet.db, melt_id=quote.quote)
|
|
assert all([p.reserved for p in proofs_db])
|
|
|
|
task = asyncio.create_task(
|
|
wallet.melt(
|
|
proofs=send_proofs,
|
|
invoice=invoice_payment_request,
|
|
fee_reserve_sat=quote.fee_reserve,
|
|
quote_id=quote.quote,
|
|
)
|
|
)
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
|
|
# simulate a and kill the task
|
|
task.cancel()
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
# verify that the proofs are still reserved
|
|
proofs_db = await get_proofs(db=wallet.db, melt_id=quote.quote)
|
|
assert all([p.reserved for p in proofs_db])
|
|
|
|
# verify that the proofs are still pending
|
|
states = await wallet.check_proof_state(send_proofs)
|
|
assert all([s.pending for s in states.states])
|
|
|
|
# succeed the payment
|
|
settle_invoice(preimage=preimage)
|
|
|
|
await asyncio.sleep(SLEEP_TIME)
|
|
|
|
# get the melt quote
|
|
melt_quote = await wallet.get_melt_quote(quote.quote)
|
|
assert melt_quote
|
|
assert melt_quote.paid
|
|
|
|
# verify that get_melt_quote unset all proofs as not pending anymore
|
|
proofs_db_later = await get_proofs(db=wallet.db, melt_id=quote.quote)
|
|
assert len(proofs_db_later) == 0
|