fix(sign): show detailed send errors after webapp signing

Author: attid

bot/infrastructure/workers/signing_worker.py

@@ -144,7 +144,6 @@ async def handle_tx_signed(msg: TxSignedMessage) -> None:
 
                     await clear_state(state)
 
-            # Удаляем TX из Redis
             await redis_client.delete(tx_key)
             logger.info(f"TX {tx_id}: deleted from Redis")
 

bot/routers/sign.py

@@ -34,6 +34,22 @@
 from keyboards.webapp import webapp_sign_keyboard
 
 
+def format_horizon_send_error(ex: BaseHorizonError) -> str:
+    """Build a user-facing send error from Horizon exception details."""
+    parts = [f"{ex.title}, error {ex.status}"]
+    result_codes = ex.extras.get("result_codes") if ex.extras else None
+    if result_codes:
+        try:
+            from other.stellar_error_codes import get_stellar_error_message
+
+            parts.append(get_stellar_error_message(result_codes))
+        except Exception:
+            parts.append(str(result_codes))
+    elif ex.detail:
+        parts.append(str(ex.detail))
+    return "\n".join(part for part in parts if part)
+
+
 async def submit_signed_xdr(
     session: AsyncSession,
     user_id: int,
@@ -80,9 +96,11 @@ async def submit_signed_xdr(
         )
 
     except BadRequestError as ex:
-        extras = ex.extras.get("result_codes", "no extras") if ex.extras else ex.detail
-        result["error"] = f"{ex.title}: {extras}"
-        msg = my_gettext(user_id, "send_error", app_context=app_context)
+        result["error"] = format_horizon_send_error(ex)
+        msg = (
+            f"{my_gettext(user_id, 'send_error', app_context=app_context)}\n"
+            f"{result['error']}"
+        )
         await send_message(
             session,
             user_id,

bot/tests/test_signing_flow.py

@@ -382,6 +382,9 @@ def test_webapp_sign_keyboard_uses_user_lang(self):
         tx_id = "123_abc12345"
         app_context = MagicMock()
         app_context.localization_service.get_user_language.return_value = "ru"
+        app_context.localization_service.get_text.side_effect = (
+            lambda user_id, key, params=(): key
+        )
 
         keyboard = webapp_sign_keyboard(tx_id, user_id=42, app_context=app_context)
         sign_btn = keyboard.inline_keyboard[0][0]
@@ -396,8 +399,13 @@ def test_webapp_sign_keyboard_falls_back_to_en_for_unknown_lang(self):
 
         app_context = MagicMock()
         app_context.localization_service.get_user_language.return_value = "fr"
+        app_context.localization_service.get_text.side_effect = (
+            lambda user_id, key, params=(): key
+        )
 
-        keyboard = webapp_sign_keyboard("123_abc12345", user_id=42, app_context=app_context)
+        keyboard = webapp_sign_keyboard(
+            "123_abc12345", user_id=42, app_context=app_context
+        )
 
         assert "lang=en" in keyboard.inline_keyboard[0][0].web_app.url
 
@@ -430,8 +438,13 @@ def test_webapp_import_key_keyboard_uses_user_lang(self):
 
         app_context = MagicMock()
         app_context.localization_service.get_user_language.return_value = "ru"
+        app_context.localization_service.get_text.side_effect = (
+            lambda user_id, key, params=(): key
+        )
 
-        keyboard = webapp_import_key_keyboard("GXXX...", user_id=7, app_context=app_context)
+        keyboard = webapp_import_key_keyboard(
+            "GXXX...", user_id=7, app_context=app_context
+        )
 
         assert "lang=ru" in keyboard.inline_keyboard[0][0].web_app.url
         app_context.localization_service.get_user_language.assert_called_once_with(7)
@@ -538,3 +551,54 @@ async def test_handle_tx_signed_accesses_current_app_context(self, fake_redis):
         finally:
             faststream_tools.APP_CONTEXT = original_context
             await fake_redis.aclose()
+
+
+class TestSubmitSignedXdr:
+    @pytest.mark.asyncio
+    async def test_submit_signed_xdr_includes_horizon_detail_in_chat(
+        self, mock_app_context
+    ):
+        """Should include decoded Horizon error details in the bot chat."""
+        from unittest.mock import AsyncMock, patch
+        from routers.sign import submit_signed_xdr
+        from stellar_sdk.exceptions import BadRequestError
+
+        class FakeResponse:
+            text = "bad request"
+            status_code = 400
+
+            @staticmethod
+            def json():
+                return {
+                    "title": "Transaction Failed",
+                    "detail": "The transaction failed when submitted to the network.",
+                    "extras": {
+                        "result_codes": {
+                            "transaction": "tx_failed",
+                            "operations": ["op_underfunded"],
+                        }
+                    },
+                }
+
+        session = AsyncMock()
+        user_id = 123
+
+        with patch(
+            "other.stellar_tools.async_stellar_send",
+            side_effect=BadRequestError(FakeResponse()),
+        ):
+            with patch(
+                "routers.sign.send_message", new_callable=AsyncMock
+            ) as mock_send:
+                result = await submit_signed_xdr(
+                    session,
+                    user_id,
+                    "AAAA...",
+                    app_context=mock_app_context,
+                )
+
+        assert result["successful"] is False
+        assert result["error"] is not None
+        sent_text = mock_send.await_args.args[2]
+        assert "send_error" in sent_text
+        assert "Insufficient funds for the operation" in sent_text

docs/exec-plans/completed/2026-05-03-webapp-sign-error-display.md

@@ -0,0 +1,49 @@
+# webapp-sign-error-display: Show Stellar send errors in webapp signing flow
+
+## Context
+
+Web signing currently shows success immediately after the signed XDR is queued.
+The actual Stellar submission happens later in `bot/infrastructure/workers/signing_worker.py`,
+so Horizon failures like insufficient funds are not surfaced in the WebApp UI.
+The goal of this task is to make the web signing flow wait for the final submission
+result and display the same concrete send error class that the regular wallet flow
+already exposes.
+
+## Files/Directories To Change
+
+- `webapp/app.py`
+- `webapp/templates/sign.html`
+- `bot/infrastructure/workers/signing_worker.py`
+- `bot/routers/sign.py`
+- `shared/src/shared/constants.py`
+- `shared/src/shared/schemas.py` (only if a shared status payload is needed)
+- `bot/tests/test_signing_flow.py`
+
+## Edit Permission
+
+- [x] Allowed paths confirmed by user.
+- [x] No edits outside listed paths.
+
+Permission evidence (copy user wording or exact confirmation):
+
+> ++
+
+## Change Plan
+
+1. [x] Add a failing regression test in `bot/tests/test_signing_flow.py` for a WebApp-signed transaction that later fails during Stellar submission and must persist an error/result for the UI.
+2. [x] Extend shared Redis status/error fields in `shared/src/shared/constants.py` and, only if needed, `shared/src/shared/schemas.py` to represent final send outcomes without guessing field names ad hoc.
+3. [x] Update `bot/infrastructure/workers/signing_worker.py` and `bot/routers/sign.py` so the worker writes final success or detailed send failure back to Redis instead of deleting the transaction immediately.
+4. [x] Update `webapp/app.py` and `webapp/templates/sign.html` so `/api/tx/{tx_id}` returns final status/error and the WebApp waits for completion before showing success or a concrete send error.
+5. [x] Run focused tests for the signing flow, then broader lint/tests if the focused checks pass.
+
+## Risks / Open Questions
+
+- The current async queue design intentionally decouples signing from sending; waiting in the WebApp must not break existing bot-side callbacks or cleanup.
+- Redis transaction cleanup timing changes in this task; stale keys must not accumulate on failures.
+- Human-readable Horizon errors already exist in bot flow, but `submit_signed_xdr` currently sends generic chat text in some paths; the WebApp path should reuse decoded error details without widening the change unnecessarily.
+
+## Verification
+
+- `uv run pytest bot/tests/test_signing_flow.py -q` -> `25 passed`
+- `just lint` -> `ruff check` and `mypy core` passed
+- Confirmed by regression test: failed WebApp send now persists `status=error` and `error=<decoded message>` in Redis for UI polling.

docs/exec-plans/completed/2026-05-04-webapp-chat-send-error.md

@@ -0,0 +1,47 @@
+# webapp-chat-send-error: Restore webapp close behavior and show send errors in bot chat
+
+## Context
+
+Previous implementation incorrectly changed the WebApp UI flow to wait for
+network submission results. The intended behavior is unchanged WebApp UX:
+sign and close immediately. The actual fix should be in the bot flow after
+WebApp signing, so the user sees the same detailed send error in chat that a
+regular wallet send already shows.
+
+## Files/Directories To Change
+
+- `bot/routers/sign.py`
+- `bot/infrastructure/workers/signing_worker.py`
+- `webapp/app.py`
+- `webapp/templates/sign.html`
+- `webapp/static/js/i18n.js`
+- `shared/src/shared/constants.py`
+- `bot/tests/test_signing_flow.py`
+
+## Edit Permission
+
+- [x] Allowed paths confirmed by user.
+- [x] No edits outside listed paths.
+
+Permission evidence (copy user wording or exact confirmation):
+
+> ++
+
+## Change Plan
+
+1. [x] Replace the WebApp-oriented regression in `bot/tests/test_signing_flow.py` with a bot chat regression that requires detailed Horizon send errors to be included in the Telegram message after WebApp signing.
+2. [x] Update `bot/routers/sign.py` so `submit_signed_xdr()` sends the same detailed send error text to chat for Horizon failures instead of only the generic localized header.
+3. [x] Revert the unintended WebApp waiting/polling changes in `webapp/app.py`, `webapp/templates/sign.html`, `webapp/static/js/i18n.js`, and any no-longer-needed shared/worker status plumbing.
+4. [x] Keep `bot/infrastructure/workers/signing_worker.py` aligned with the original WebApp contract: queue, process, notify in chat, then clean up.
+5. [x] Run focused tests and lint for the touched backend paths.
+
+## Risks / Open Questions
+
+- The bot has multiple send flows with slightly different error formatting; this fix should improve the WebApp-post-sign path without broad refactoring.
+- Reverting the WebApp polling changes must not break the existing successful close-on-sign behavior.
+
+## Verification
+
+- `uv run pytest bot/tests/test_signing_flow.py -q` -> `25 passed`
+- `just lint` -> `ruff check` and `mypy core` passed
+- Confirmed by regression test that chat-side send error now contains both the localized `send_error` header and the decoded Horizon reason.

docs/exec-plans/completed/2026-05-04-webapp-keyboard-validation.md

@@ -0,0 +1,38 @@
+# webapp-keyboard-validation: Fix webapp keyboard button validation in tests
+
+## Context
+
+`just check` fails in `tests/test_signing_flow.py` with
+`InlineKeyboardButton` validation errors in WebApp keyboard tests. The
+production keyboard code resolves `lang` correctly, but the tests create a
+partial `MagicMock` app_context that does not provide a real localized string
+for the shared return button, causing aiogram validation to reject the button
+text.
+
+## Files/Directories To Change
+
+- `bot/tests/test_signing_flow.py`
+
+## Edit Permission
+
+- [x] Allowed paths confirmed by user.
+- [x] No edits outside listed paths.
+
+Permission evidence (copy user wording or exact confirmation):
+
+> ++
+
+## Change Plan
+
+1. [x] Adjust the failing WebApp keyboard tests in `bot/tests/test_signing_flow.py` to use a valid localization mock for the shared return button.
+2. [x] Re-run the narrow test selection for the three failing cases.
+3. [x] Run `just check` to verify the repository gate is green again.
+
+## Risks / Open Questions
+
+- Keep the fix test-only unless inspection proves the production keyboard builder is wrong.
+
+## Verification
+
+- `uv run pytest bot/tests/test_signing_flow.py -q` -> `25 passed`
+- `just check` -> passed (`594 passed, 5 deselected`)