fix: error handling

mutiny-core/src/error.rs

@@ -171,8 +171,10 @@ pub enum MutinyError {
     /// Token already spent.
     #[error("Token has been already spent.")]
     TokenAlreadySpent,
-    #[error("Fedimint external note reissuance failed.")]
+    #[error("Fedimint external note re-issuance failed.")]
     FedimintReissueFailed,
+    #[error("Fedimint external note re-issuance resulted in stale outcome state.")]
+    FedimintReissueStaleState,
     #[error(transparent)]
     Other(#[from] anyhow::Error),
 }

mutiny-core/src/federation.rs

@@ -9,7 +9,7 @@ use crate::{
         get_payment_info, list_payment_info, persist_payment_info, MutinyStorage, VersionedValue,
     },
     utils::sleep,
-    HTLCStatus, MutinyInvoice, DEFAULT_PAYMENT_TIMEOUT, DEFAULT_REISSUE_TIMEOUT,
+    HTLCStatus, MutinyInvoice, DEFAULT_PAYMENT_TIMEOUT,
 };
 use async_trait::async_trait;
 use bip39::Mnemonic;
@@ -72,6 +72,12 @@ use std::{
     sync::atomic::{AtomicU32, Ordering},
 };
 
+// The amount of time in milliseconds to wait for
+// checking the status of a fedimint OOB re-issuance. This
+// is to work around their stream status checking
+// when wanting just the current status.
+const FEDIMINT_OOB_REISSUE_TIMEOUT_CHECK_MS: u64 = 30;
+
 // The amount of time in milliseconds to wait for
 // checking the status of a fedimint payment. This
 // is to work around their stream status checking
@@ -616,15 +622,31 @@ impl<S: MutinyStorage> FederationClient<S> {
         // Reissue `OOBNotes`
         let operation_id = mint_module.reissue_external_notes(oob_notes, ()).await?;
 
-        // TODO: (@leonardo) re-think about the results and errors that we need/want
-        match process_reissue_outcome(&mint_module, operation_id, self.logger.clone()).await? {
-            ReissueExternalNotesState::Created | ReissueExternalNotesState::Failed(_) => {
-                log_trace!(self.logger, "re-issuance of OOBNotes failed!");
+        match process_reissue_outcome(
+            &mint_module,
+            operation_id,
+            FEDIMINT_OOB_REISSUE_TIMEOUT_CHECK_MS,
+            self.logger.clone(),
+        )
+        .await?
+        {
+            ReissueExternalNotesState::Done => {
+                log_trace!(self.logger, "re-issuance of OOBNotes was successful!");
+                Ok(())
+            }
+            ReissueExternalNotesState::Failed(reason) => {
+                log_trace!(
+                    self.logger,
+                    "re-issuance of OOBNotes failed explicitly, reason: {reason}"
+                );
                 Err(MutinyError::FedimintReissueFailed)
             }
             _ => {
-                log_trace!(self.logger, "re-issuance of OOBNotes was successful!");
-                Ok(())
+                log_trace!(
+                    self.logger,
+                    "re-issuance of OOBNotes explicitly failed, due to outcome with a stale state!"
+                );
+                Err(MutinyError::FedimintReissueStaleState)
             }
         }
     }
@@ -889,21 +911,22 @@ where
 async fn process_reissue_outcome(
     mint_module: &MintClientModule,
     operation_id: OperationId,
+    timeout: u64,
     logger: Arc<MutinyLogger>,
 ) -> Result<ReissueExternalNotesState, MutinyError> {
-    // Subscribe/Process the outcome based on `ReissueExternalNotesState`
+    // Subscribe to the outcome based on `ReissueExternalNotesState`
     let stream_or_outcome = mint_module
         .subscribe_reissue_external_notes(operation_id)
         .await
         .map_err(MutinyError::Other)?;
 
+    // Process the outcome based on `ReissueExternalNotesState`
     match stream_or_outcome {
         UpdateStreamOrOutcome::Outcome(outcome) => {
             log_trace!(logger, "outcome received {:?}", outcome);
             Ok(outcome)
         }
         UpdateStreamOrOutcome::UpdateStream(mut stream) => {
-            let timeout = DEFAULT_REISSUE_TIMEOUT;
             let timeout_fut = sleep(timeout as i32);
             pin_mut!(timeout_fut);
 
@@ -924,7 +947,13 @@ async fn process_reissue_outcome(
                             );
                             return Ok(outcome);
                         }
-                        _ => { /* ignore and continue */ }
+                        _ => {
+                            log_trace!(
+                                logger,
+                                "streamed outcome received is not final {:?}, skipping",
+                                outcome
+                            );
+                        }
                     }
                 };
             }

mutiny-core/src/lib.rs

@@ -119,7 +119,6 @@ use crate::utils::parse_profile_metadata;
 use mockall::{automock, predicate::*};
 
 const DEFAULT_PAYMENT_TIMEOUT: u64 = 30;
-const DEFAULT_REISSUE_TIMEOUT: u64 = 50;
 const MAX_FEDERATION_INVOICE_AMT: u64 = 200_000;
 const SWAP_LABEL: &str = "SWAP";
 const MELT_CASHU_TOKEN: &str = "Cashu Token Melt";

mutiny-wasm/src/error.rs

@@ -168,8 +168,10 @@ pub enum MutinyJsError {
     /// Token already spent.
     #[error("Token has been already spent.")]
     TokenAlreadySpent,
-    #[error("Fedimint external note reissuance failed.")]
+    #[error("Fedimint external note re-issuance failed.")]
     FedimintReissueFailed,
+    #[error("Fedimint external note re-issuance resulted in stale outcome state.")]
+    FedimintReissueStaleState,
     /// Unknown error.
     #[error("Unknown Error")]
     UnknownError,
@@ -241,6 +243,7 @@ impl From<MutinyError> for MutinyJsError {
             MutinyError::PayjoinCreateRequest => MutinyJsError::PayjoinCreateRequest,
             MutinyError::PayjoinResponse(e) => MutinyJsError::PayjoinResponse(e.to_string()),
             MutinyError::FedimintReissueFailed => MutinyJsError::FedimintReissueFailed,
+            MutinyError::FedimintReissueStaleState => MutinyJsError::FedimintReissueStaleState,
         }
     }
 }