feat: reject unprocessable transactions with sendTransaction status ERROR

A transaction that decodes as XDR but cannot be processed (for example an
operation the semantics do not support) previously came back as a generic
-32602 JSON-RPC error. Real stellar-rpc reports these admission-time
rejections as status ERROR with a txMALFORMED TransactionResult in
errorResultXdr, so komet-node now does the same: the transaction never
reaches the ledger, no receipt is stored, and getTransaction stays
NOT_FOUND. Undecodable XDR remains -32602, matching real stellar-rpc.

TRY_AGAIN_LATER stays intentionally unreturned: it signals mempool
backpressure, which cannot arise in a synchronous node without a mempool.

Author: RaoulSchaffranek

docs/notes.md

@@ -34,7 +34,7 @@ The tests do not yet cover `bytes` / `address` SCVal arguments or `SCVec` / `SCM
 ## Known gaps
 
 - `resultXdr` / `resultMetaXdr` are empty stubs (contract return values not surfaced).
-- `sendTransaction` never returns `ERROR` or `TRY_AGAIN_LATER` (a failed transaction is reported as `PENDING`, then `FAILED` by `getTransaction`); `errorResultXdr` / `diagnosticEventsXdr` are never returned.
+- `sendTransaction`'s `errorResultXdr` is always a generic `txMALFORMED` result (no per-cause codes such as `txBAD_SEQ` — sequence numbers, fees, and signatures are not modelled), and `diagnosticEventsXdr` is never populated (both fields are optional in the spec). `TRY_AGAIN_LATER` is never returned by design: it signals mempool backpressure, which cannot arise in a synchronous node without a mempool.
 - `SCVec` / `SCMap` contract arguments are not yet encoded.
 - `simulateTransaction`, `getEvents`, `getLedgerEntries`, `getFeeStats`, and TTL/footprint operations are not implemented.
 - Receipts are not a stable format: older io-dirs store `ledger`/`createdAt` with pre-spec types and lack `applicationOrder`/`feeBump`. Resume only io-dirs written by the same version, or start fresh.

docs/server.md

@@ -122,6 +122,8 @@ The node retains every ledger since genesis, so `oldestLedger` is always 0 and t
 
 Resubmitting a transaction whose hash already has a receipt returns status `DUPLICATE` without re-executing it: the ledger does not advance and the stored receipt is untouched.
 
+A transaction that decodes as XDR but cannot be processed (e.g. it contains an operation the semantics do not support) is rejected at admission time with status `ERROR` and an `errorResultXdr` carrying a `txMALFORMED` `TransactionResult` — mirroring how real stellar-rpc reports core's admission rejections. Such a transaction never reaches the ledger: no receipt is stored (`getTransaction` stays `NOT_FOUND`) and the ledger does not advance. Undecodable XDR remains a plain `-32602 Invalid params` error, as in real stellar-rpc. `TRY_AGAIN_LATER` is never returned: it signals mempool backpressure, and komet-node executes synchronously without a mempool, so the condition it reports cannot arise.
+
 ### `traceTransaction`
 
 `traceTransaction` retrieves the instruction trace of a previously submitted transaction. It takes a `hash` parameter (the same one `getTransaction` takes) and returns the trace that `sendTransaction` stored on that transaction's receipt. The result is the trace itself: a JSONL string with one record per executed WebAssembly instruction, or `null` when no transaction with that hash exists.

src/komet_node/server.py

@@ -11,10 +11,10 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Final
 
-from stellar_sdk import Network
+from stellar_sdk import Network, TransactionEnvelope
 
 from komet_node.interpreter import NodeInterpreter
-from komet_node.transaction import TransactionEncoder
+from komet_node.transaction import TransactionEncoder, malformed_tx_result_xdr
 
 if TYPE_CHECKING:
     from http.server import HTTPServer as HTTPServerType
@@ -192,14 +192,21 @@ def handle_rpc(self, method: str | None, params: dict[str, Any], request_id: Any
             transaction = params.get('transaction')
             if not isinstance(transaction, str):
                 return _error_str(request_id, -32602, "Invalid params: 'transaction' (XDR string) is required")
+            # Undecodable XDR is a JSON-RPC client error (-32602, as in real stellar-rpc);
+            # a transaction that decodes but cannot be processed (e.g. an unsupported
+            # operation) is instead rejected at admission time with status ERROR below.
+            try:
+                parsed = TransactionEnvelope.from_xdr(transaction, self.encoder.network_passphrase)
+            except Exception:
+                traceback.print_exc()
+                return _error_str(request_id, -32602, 'Invalid params: could not decode transaction XDR')
             try:
                 envelope, program_steps = self.encoder.build_tx_request(method, request_id, transaction, now)
             except Exception:
-                # build_tx_request both decodes XDR and validates it (e.g. rejecting
-                # sub-stroop amounts); either is a client error. Log the detail, but keep
-                # the client-facing message neutral rather than leaking internal exceptions.
+                # Log the detail, but keep the client-facing response neutral rather than
+                # leaking internal exceptions.
                 traceback.print_exc()
-                return _error_str(request_id, -32602, 'Invalid params: could not process transaction')
+                return json.dumps(self._error_status_response(request_id, parsed.hash_hex(), now))
             # A hash that already has a receipt is a duplicate submission: the semantics
             # answer DUPLICATE without running the steps (see node.md). Steps injected into
             # the <program> cell (wasm uploads) would execute *before* dispatch, though, so
@@ -256,6 +263,24 @@ def _archive_request(self, method: str | None, params: dict[str, Any], request_i
         (self.requests_dir / f'request_{self._request_count}.json').write_text(json.dumps(archive))
         self._request_count += 1
 
+    def _error_status_response(self, rpc_id: Any, tx_hash: str, now: str) -> dict[str, Any]:
+        """Synthesise the sendTransaction response for a transaction rejected at admission.
+
+        Mirrors real stellar-rpc: a transaction that decodes as XDR but cannot be processed
+        gets status ``ERROR`` with a ``txMALFORMED`` ``errorResultXdr``. It never reaches
+        the ledger, so no receipt is stored (``getTransaction`` stays ``NOT_FOUND``) and the
+        ledger does not advance.
+        """
+        metadata = json.loads((self.io_dir / 'metadata.json').read_text())
+        result = {
+            'hash': tx_hash,
+            'status': 'ERROR',
+            'errorResultXdr': malformed_tx_result_xdr(),
+            'latestLedger': metadata.get('latest_ledger', 0),
+            'latestLedgerCloseTime': now,
+        }
+        return {'jsonrpc': '2.0', 'id': rpc_id, 'result': result}
+
     def _failure_response(self, rpc_id: Any, envelope: dict[str, Any], now: str) -> dict[str, Any]:
         """Synthesise the sendTransaction response for a transaction that got stuck (failed).
 

src/komet_node/transaction.py

@@ -23,6 +23,20 @@
 _STROOPS_PER_XLM = Decimal('10000000')
 
 
+def malformed_tx_result_xdr() -> str:
+    """Base64 ``TransactionResult`` with code ``txMALFORMED`` and no fee charged.
+
+    Returned as ``errorResultXdr`` when ``sendTransaction`` rejects a transaction at
+    admission time (it decodes as XDR but cannot be processed by the semantics).
+    """
+    result = xdr.TransactionResult(
+        fee_charged=xdr.Int64(0),
+        result=xdr.TransactionResultResult(code=xdr.TransactionResultCode.txMALFORMED),
+        ext=xdr.TransactionResultExt(0),
+    )
+    return result.to_xdr()
+
+
 def _xlm_to_stroops(balance: object) -> int:
     """Convert an XLM amount (which may carry up to 7 decimals) to integer stroops.