fix(cketh): report a failed funding as failed, not pending reimbursement

`processed_transaction_status` classified every failed finalized transaction as
`PendingReimbursement`, which the Candid interface defines as "transaction
failed and will be reimbursed". A sweeper funding is never reimbursed, so
`retrieve_eth_status` and `withdrawal_status` promised a reimbursement that
nothing will ever settle — and the status would stay wrong forever, since only
recording a reimbursement moves it on.

Add a `Failed` variant to `TxFinalizedStatus` for a failure that will not be
reimbursed, and pick between the two by asking the request whether it is
reimbursable. This needs the didc override, as any addition to a returned
variant does.

Tests cover all three paths: a failed funding reports `Failed`, a successful one
still reports `Success`, and a failed *user* withdrawal still reports
`PendingReimbursement` — without that last one the first would also pass if the
branch were inverted.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: mbjorkqvist

rs/ethereum/cketh/minter/cketh_minter.did

@@ -273,6 +273,8 @@ type TxFinalizedStatus = variant {
     };
     // Transaction failed and will be reimbursed,
     PendingReimbursement : EthTransaction;
+    // Transaction failed and will not be reimbursed.
+    Failed : EthTransaction;
 };
 
 // Retrieve the status of a withdrawal request.

rs/ethereum/cketh/minter/src/endpoints.rs

@@ -171,6 +171,7 @@ pub enum TxFinalizedStatus {
         effective_transaction_fee: Option<Nat>,
     },
     PendingReimbursement(EthTransaction),
+    Failed(EthTransaction),
     Reimbursed {
         transaction_hash: String,
         reimbursed_amount: Nat,
@@ -192,6 +193,9 @@ impl Display for RetrieveEthStatus {
                 TxFinalizedStatus::PendingReimbursement(tx) => {
                     write!(f, "PendingReimbursement({})", tx.transaction_hash)
                 }
+                TxFinalizedStatus::Failed(tx) => {
+                    write!(f, "Failed({})", tx.transaction_hash)
+                }
                 TxFinalizedStatus::Reimbursed {
                     reimbursed_in_block,
                     transaction_hash,

rs/ethereum/cketh/minter/src/state/transactions/mod.rs

@@ -1000,14 +1000,18 @@ impl EthTransactions {
                 );
             }
             if tx.transaction_status() == &TransactionStatus::Failure {
-                return (
-                    RetrieveEthStatus::TxFinalized(TxFinalizedStatus::PendingReimbursement(
-                        EthTransaction {
-                            transaction_hash: tx.transaction_hash().to_string(),
-                        },
-                    )),
-                    Some(tx.as_ref()),
-                );
+                let failure = EthTransaction {
+                    transaction_hash: tx.transaction_hash().to_string(),
+                };
+                // A request that cannot be reimbursed must not report a pending reimbursement:
+                // nothing will ever settle it, so the status would stay wrong forever.
+                let status = match self.processed_withdrawal_requests.get(burn_index) {
+                    Some(request) if !request.is_reimbursable() => {
+                        TxFinalizedStatus::Failed(failure)
+                    }
+                    _ => TxFinalizedStatus::PendingReimbursement(failure),
+                };
+                return (RetrieveEthStatus::TxFinalized(status), Some(tx.as_ref()));
             }
 
             return (

rs/ethereum/cketh/minter/src/state/transactions/tests.rs

@@ -2126,6 +2126,7 @@ mod eth_transactions {
     mod sweeper_funding {
         use super::withdrawal_flow;
         use super::*;
+        use crate::endpoints::{RetrieveEthStatus, TxFinalizedStatus};
         use crate::eth_logs::LedgerSubaccount;
         use crate::lifecycle::EthereumNetwork;
         use crate::numeric::TransactionCount;
@@ -2208,6 +2209,58 @@ mod eth_transactions {
             }
         }
 
+        #[test]
+        fn should_report_a_failed_funding_as_failed_not_pending_reimbursement() {
+            let mut transactions = EthTransactions::new(TransactionNonce::ZERO);
+            let funding = sweeper_funding_request();
+            let burn_index = funding.ledger_burn_index;
+
+            let receipt = withdrawal_flow(&mut transactions, funding, TransactionStatus::Failure);
+
+            assert_eq!(
+                transactions.transaction_status(&burn_index),
+                RetrieveEthStatus::TxFinalized(TxFinalizedStatus::Failed((&receipt).into())),
+                "nothing will ever reimburse a funding, so PendingReimbursement would stay wrong \
+                 forever"
+            );
+        }
+
+        #[test]
+        fn should_report_a_successful_funding_as_success() {
+            let mut transactions = EthTransactions::new(TransactionNonce::ZERO);
+            let funding = sweeper_funding_request();
+            let burn_index = funding.ledger_burn_index;
+
+            let receipt = withdrawal_flow(&mut transactions, funding, TransactionStatus::Success);
+
+            assert_matches!(
+                transactions.transaction_status(&burn_index),
+                RetrieveEthStatus::TxFinalized(TxFinalizedStatus::Success {
+                    transaction_hash,
+                    ..
+                }) if transaction_hash == receipt.transaction_hash.to_string()
+            );
+        }
+
+        #[test]
+        fn should_still_report_a_failed_user_withdrawal_as_pending_reimbursement() {
+            let mut transactions = EthTransactions::new(TransactionNonce::ZERO);
+            let burn_index = LedgerBurnIndex::new(15);
+
+            let receipt = withdrawal_flow(
+                &mut transactions,
+                cketh_withdrawal_request_with_index(burn_index),
+                TransactionStatus::Failure,
+            );
+
+            assert_eq!(
+                transactions.transaction_status(&burn_index),
+                RetrieveEthStatus::TxFinalized(TxFinalizedStatus::PendingReimbursement(
+                    (&receipt).into()
+                ))
+            );
+        }
+
         #[test]
         fn should_still_reimburse_a_failed_user_withdrawal() {
             let mut transactions = EthTransactions::new(TransactionNonce::ZERO);