From 8b3b59e176881e7df7bb4775b0f107f50d8fa3ec Mon Sep 17 00:00:00 2001 From: 9qeklajc Date: Sat, 18 Jul 2026 14:16:30 +0200 Subject: [PATCH 1/2] fix: propagate Cashu transaction storage errors --- routstr/core/db.py | 37 ++++++-------- .../test_cashu_transaction_storage_errors.py | 51 +++++++++++++++++++ 2 files changed, 66 insertions(+), 22 deletions(-) create mode 100644 tests/unit/test_cashu_transaction_storage_errors.py diff --git a/routstr/core/db.py b/routstr/core/db.py index 9ebb87e9..6e629da1 100644 --- a/routstr/core/db.py +++ b/routstr/core/db.py @@ -288,29 +288,22 @@ async def store_cashu_transaction( source: str = "x-cashu", api_key_hashed_key: str | None = None, ) -> bool: - try: - async with create_session() as session: - tx = CashuTransaction( - token=token, - amount=amount, - unit=unit, - mint_url=mint_url, - type=typ, - request_id=request_id, - collected=collected, - created_at=created_at or int(time.time()), - source=source, - api_key_hashed_key=api_key_hashed_key, - ) - session.add(tx) - await session.commit() - return True - except Exception as e: - logger.warning( - f"Failed to store cashu transaction: {e} (type={typ})", - extra={"error": str(e), "type": typ}, + async with create_session() as session: + tx = CashuTransaction( + token=token, + amount=amount, + unit=unit, + mint_url=mint_url, + type=typ, + request_id=request_id, + collected=collected, + created_at=created_at or int(time.time()), + source=source, + api_key_hashed_key=api_key_hashed_key, ) - return False + session.add(tx) + await session.commit() + return True class UpstreamProviderRow(SQLModel, table=True): # type: ignore diff --git a/tests/unit/test_cashu_transaction_storage_errors.py b/tests/unit/test_cashu_transaction_storage_errors.py new file mode 100644 index 00000000..cc6d5221 --- /dev/null +++ b/tests/unit/test_cashu_transaction_storage_errors.py @@ -0,0 +1,51 @@ +from unittest.mock import AsyncMock, patch + +import pytest + +from routstr.core.db import store_cashu_transaction + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + "error", + [ + OSError("disk full"), + RuntimeError("connection lost"), + ConnectionRefusedError("database unavailable"), + ], +) +async def test_store_cashu_transaction_propagates_commit_errors( + error: Exception, +) -> None: + session = AsyncMock() + session.commit.side_effect = error + session.__aenter__.return_value = session + session.__aexit__.return_value = None + + with patch("routstr.core.db.create_session", return_value=session): + with pytest.raises(type(error), match=str(error)): + await store_cashu_transaction( + token="cashuAtest", + amount=1_000, + unit="sat", + mint_url="https://mint.example", + typ="out", + request_id="request-1", + ) + + +@pytest.mark.asyncio +async def test_store_cashu_transaction_returns_true_after_commit() -> None: + session = AsyncMock() + session.__aenter__.return_value = session + session.__aexit__.return_value = None + + with patch("routstr.core.db.create_session", return_value=session): + stored = await store_cashu_transaction( + token="cashuAtest", + amount=1_000, + unit="sat", + ) + + assert stored is True + session.commit.assert_awaited_once() From 90da3803c65adf8e819b5ac06be88f05d8fbe605 Mon Sep 17 00:00:00 2001 From: 9qeklajc Date: Sat, 18 Jul 2026 14:22:16 +0200 Subject: [PATCH 2/2] fix: preserve caller recovery on storage errors --- routstr/core/admin.py | 28 ++++++++++----- routstr/core/db.py | 36 +++++++++++-------- routstr/upstream/auto_topup.py | 21 +++++------ routstr/wallet.py | 10 +++--- tests/unit/test_admin_withdraw.py | 31 ++++++++++++++++ tests/unit/test_auto_topup.py | 2 +- .../test_cashu_transaction_storage_errors.py | 7 +++- 7 files changed, 95 insertions(+), 40 deletions(-) diff --git a/routstr/core/admin.py b/routstr/core/admin.py index c6738efc..09f14f98 100644 --- a/routstr/core/admin.py +++ b/routstr/core/admin.py @@ -434,15 +434,25 @@ async def withdraw( token = await send_token( withdraw_request.amount, withdraw_request.unit, effective_mint ) - await store_cashu_transaction( - token=token, - amount=withdraw_request.amount, - unit=withdraw_request.unit, - mint_url=effective_mint, - typ="out", - collected=False, - source="admin", - ) + try: + await store_cashu_transaction( + token=token, + amount=withdraw_request.amount, + unit=withdraw_request.unit, + mint_url=effective_mint, + typ="out", + collected=False, + source="admin", + ) + except Exception: + logger.critical( + "Admin withdrawal token issued without a persisted audit record", + extra={ + "amount": withdraw_request.amount, + "unit": withdraw_request.unit, + "mint_url": effective_mint, + }, + ) return {"token": token} diff --git a/routstr/core/db.py b/routstr/core/db.py index 6e629da1..d0d7805e 100644 --- a/routstr/core/db.py +++ b/routstr/core/db.py @@ -288,21 +288,29 @@ async def store_cashu_transaction( source: str = "x-cashu", api_key_hashed_key: str | None = None, ) -> bool: - async with create_session() as session: - tx = CashuTransaction( - token=token, - amount=amount, - unit=unit, - mint_url=mint_url, - type=typ, - request_id=request_id, - collected=collected, - created_at=created_at or int(time.time()), - source=source, - api_key_hashed_key=api_key_hashed_key, + try: + async with create_session() as session: + tx = CashuTransaction( + token=token, + amount=amount, + unit=unit, + mint_url=mint_url, + type=typ, + request_id=request_id, + collected=collected, + created_at=created_at or int(time.time()), + source=source, + api_key_hashed_key=api_key_hashed_key, + ) + session.add(tx) + await session.commit() + except Exception: + logger.critical( + "Failed to store Cashu transaction", + extra={"type": typ, "request_id": request_id, "source": source}, + exc_info=True, ) - session.add(tx) - await session.commit() + raise return True diff --git a/routstr/upstream/auto_topup.py b/routstr/upstream/auto_topup.py index 3517be7d..cb1ede96 100644 --- a/routstr/upstream/auto_topup.py +++ b/routstr/upstream/auto_topup.py @@ -142,16 +142,17 @@ async def _check_and_topup(row: UpstreamProviderRow) -> None: ) return - stored = await store_cashu_transaction( - token=token, - amount=amount, - unit="sat", - mint_url=mint_url, - typ="out", - collected=False, - source="auto_topup", - ) - if not stored: + try: + await store_cashu_transaction( + token=token, + amount=amount, + unit="sat", + mint_url=mint_url, + typ="out", + collected=False, + source="auto_topup", + ) + except Exception: logger.critical( "Aborting auto top-up because its cashu token could not be persisted", extra={"provider_id": row.id, "mint_url": mint_url}, diff --git a/routstr/wallet.py b/routstr/wallet.py index 68f93cc2..cd7798d2 100644 --- a/routstr/wallet.py +++ b/routstr/wallet.py @@ -745,11 +745,11 @@ async def credit_balance( ) except Exception: pass - - logger.debug( - "Cashu token successfully redeemed and stored", - extra={"amount": amount, "unit": unit, "mint_url": mint_url}, - ) + else: + logger.debug( + "Cashu token successfully redeemed and stored", + extra={"amount": amount, "unit": unit, "mint_url": mint_url}, + ) return amount except Exception as e: logger.error( diff --git a/tests/unit/test_admin_withdraw.py b/tests/unit/test_admin_withdraw.py index 1c3a1919..e54f7d01 100644 --- a/tests/unit/test_admin_withdraw.py +++ b/tests/unit/test_admin_withdraw.py @@ -49,3 +49,34 @@ async def test_withdraw_uses_effective_mint_and_records_outgoing_transaction( collected=False, source="admin", ) + + +@pytest.mark.asyncio +async def test_withdraw_returns_issued_token_when_audit_storage_fails( + monkeypatch: pytest.MonkeyPatch, +) -> None: + mint = "https://primary.example" + proofs = [SimpleNamespace(amount=100)] + token = "cashuBrecoverable" + + monkeypatch.setattr(admin, "get_wallet", AsyncMock(return_value=object())) + monkeypatch.setattr( + admin, "get_proofs_per_mint_and_unit", Mock(return_value=proofs) + ) + monkeypatch.setattr( + admin, "slow_filter_spend_proofs", AsyncMock(return_value=proofs) + ) + monkeypatch.setattr(admin, "send_token", AsyncMock(return_value=token)) + monkeypatch.setattr( + admin, + "store_cashu_transaction", + AsyncMock(side_effect=RuntimeError("database unavailable")), + ) + critical = Mock() + monkeypatch.setattr(admin.logger, "critical", critical) + monkeypatch.setattr(admin.settings, "primary_mint", mint) + + result = await admin.withdraw(Mock(), admin.WithdrawRequest(amount=75)) + + assert result == {"token": token} + critical.assert_called_once() diff --git a/tests/unit/test_auto_topup.py b/tests/unit/test_auto_topup.py index c05c85e5..2adb13e6 100644 --- a/tests/unit/test_auto_topup.py +++ b/tests/unit/test_auto_topup.py @@ -136,7 +136,7 @@ async def test_auto_topup_does_not_send_untracked_token() -> None: ), patch( "routstr.upstream.auto_topup.store_cashu_transaction", - AsyncMock(return_value=False), + AsyncMock(side_effect=RuntimeError("database unavailable")), ), ): await _check_and_topup(_row()) diff --git a/tests/unit/test_cashu_transaction_storage_errors.py b/tests/unit/test_cashu_transaction_storage_errors.py index cc6d5221..b26b4115 100644 --- a/tests/unit/test_cashu_transaction_storage_errors.py +++ b/tests/unit/test_cashu_transaction_storage_errors.py @@ -22,7 +22,10 @@ async def test_store_cashu_transaction_propagates_commit_errors( session.__aenter__.return_value = session session.__aexit__.return_value = None - with patch("routstr.core.db.create_session", return_value=session): + with ( + patch("routstr.core.db.create_session", return_value=session), + patch("routstr.core.db.logger.critical") as critical, + ): with pytest.raises(type(error), match=str(error)): await store_cashu_transaction( token="cashuAtest", @@ -33,6 +36,8 @@ async def test_store_cashu_transaction_propagates_commit_errors( request_id="request-1", ) + critical.assert_called_once() + @pytest.mark.asyncio async def test_store_cashu_transaction_returns_true_after_commit() -> None: