wip(feat): reissue ecash from OOBNotes

wip(feat): reissue ecash notes from `OOBNotes``

wip: working version 🚀

mutiny-core/src/error.rs

@@ -162,6 +162,8 @@ pub enum MutinyError {
     /// Payjoin configuration error
     #[error("Payjoin configuration failed.")]
     PayjoinConfigError,
+    #[error("Fedimint external note reissuance failed.")]
+    FedimintReissueFailed,
     #[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,
+    HTLCStatus, MutinyInvoice, DEFAULT_PAYMENT_TIMEOUT, DEFAULT_REISSUE_TIMEOUT,
 };
 use async_trait::async_trait;
 use bip39::Mnemonic;
@@ -52,7 +52,7 @@ use fedimint_ln_client::{
 };
 use fedimint_ln_common::lightning_invoice::RoutingFees;
 use fedimint_ln_common::LightningCommonInit;
-use fedimint_mint_client::MintClientInit;
+use fedimint_mint_client::{MintClientInit, MintClientModule, OOBNotes, ReissueExternalNotesState};
 use fedimint_wallet_client::{WalletClientInit, WalletClientModule};
 use futures::future::{self};
 use futures_util::{pin_mut, StreamExt};
@@ -603,6 +603,29 @@ impl<S: MutinyStorage> FederationClient<S> {
         }
     }
 
+    pub(crate) async fn reissue(&self, oob_notes: OOBNotes) -> Result<bool, MutinyError> {
+        let logger = Arc::clone(&self.logger);
+
+        // Get the `MintClientModule`
+        let mint_module = self.fedimint_client.get_first_module::<MintClientModule>();
+
+        // TODO: (@leonardo) Do we need any `extra_meta` ?
+        // 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, logger.clone()).await? {
+            ReissueExternalNotesState::Created | ReissueExternalNotesState::Failed(_) => {
+                log_info!(logger, "re-issuance of OOBNotes failed!");
+                Err(MutinyError::FedimintReissueFailed)
+            }
+            _ => {
+                log_info!(logger, "re-issuance of OOBNotes was successful!");
+                Ok(true)
+            }
+        }
+    }
+
     pub async fn get_mutiny_federation_identity(&self) -> FederationIdentity {
         let gateway_fees = self.gateway_fee().await.ok();
 
@@ -860,6 +883,53 @@ where
     invoice
 }
 
+async fn process_reissue_outcome(
+    mint_module: &MintClientModule,
+    operation_id: OperationId,
+    logger: Arc<MutinyLogger>,
+) -> Result<ReissueExternalNotesState, MutinyError> {
+    // Subscribe/Process the outcome based on `ReissueExternalNotesState`
+    let stream_or_outcome = mint_module
+        .subscribe_reissue_external_notes(operation_id)
+        .await
+        .map_err(|e| MutinyError::Other(e))?;
+
+    match stream_or_outcome {
+        UpdateStreamOrOutcome::Outcome(outcome) => {
+            log_trace!(logger, "outcome received {:?}", outcome);
+            return Ok(outcome);
+        }
+        UpdateStreamOrOutcome::UpdateStream(mut stream) => {
+            let timeout = DEFAULT_REISSUE_TIMEOUT * 1_000;
+            let timeout_fut = sleep(timeout as i32);
+            pin_mut!(timeout_fut);
+
+            log_trace!(logger, "started timeout future {:?}", timeout);
+
+            while let future::Either::Left((outcome_opt, _)) =
+                future::select(stream.next(), &mut timeout_fut).await
+            {
+                if let Some(outcome) = outcome_opt {
+                    log_trace!(logger, "streamed outcome received {:?}", outcome);
+
+                    match outcome {
+                        ReissueExternalNotesState::Failed(_) | ReissueExternalNotesState::Done => {
+                            log_trace!(
+                                logger,
+                                "streamed outcome received is final {:?}, returning",
+                                outcome
+                            );
+                            return Ok(outcome);
+                        }
+                        _ => { /* ignore and continue */ }
+                    }
+                };
+            }
+            return Err(MutinyError::FedimintReissueFailed);
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct FedimintStorage<S: MutinyStorage> {
     pub(crate) storage: S,

mutiny-core/src/lib.rs

@@ -7,7 +7,6 @@
     clippy::arc_with_non_send_sync,
     type_alias_bounds
 )]
-extern crate core;
 
 pub mod auth;
 mod chain;
@@ -84,6 +83,7 @@ use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::{hashes::sha256, Network};
 use fedimint_core::{api::InviteCode, config::FederationId};
+use fedimint_mint_client::OOBNotes;
 use futures::{pin_mut, select, FutureExt};
 use futures_util::join;
 use hex_conservative::{DisplayHex, FromHex};
@@ -113,6 +113,7 @@ use crate::utils::parse_profile_metadata;
 use mockall::{automock, predicate::*};
 
 const DEFAULT_PAYMENT_TIMEOUT: u64 = 30;
+const DEFAULT_REISSUE_TIMEOUT: u64 = 60;
 const MAX_FEDERATION_INVOICE_AMT: u64 = 200_000;
 const SWAP_LABEL: &str = "SWAP";
 
@@ -1308,6 +1309,26 @@ impl<S: MutinyStorage> MutinyWallet<S> {
         })
     }
 
+    pub async fn reissue_oob_notes(&self, oob_notes: OOBNotes) -> Result<bool, MutinyError> {
+        let federation_lock = self.federations.read().await;
+        let federation_ids = self.list_federation_ids().await?;
+
+        let maybe_federation_id = federation_ids
+            .iter()
+            .find(|id| id.to_prefix() == oob_notes.federation_id_prefix());
+
+        if let Some(fed_id) = maybe_federation_id {
+            log_info!(self.logger, "found federation_id {:?}", fed_id);
+            let fedimint_client = federation_lock.get(&fed_id).ok_or(MutinyError::NotFound)?;
+            log_info!(self.logger, "got fedimint client for federation_id {:?}", fed_id);
+            let reissue = fedimint_client.reissue(oob_notes).await?;
+            log_info!(self.logger, "successfully reissued for federation_id {:?}", fed_id);
+            Ok(reissue)
+        } else {
+            return Err(MutinyError::NotFound);
+        }
+    }
+
     /// Estimate the fee before trying to sweep from federation
     pub async fn estimate_sweep_federation_fee(
         &self,

mutiny-wasm/Cargo.toml

@@ -45,6 +45,7 @@ once_cell = "1.18.0"
 hex-conservative = "0.1.1"
 payjoin = { version = "0.13.0", features = ["send", "base64"] }
 fedimint-core = { git = "https://github.com/fedimint/fedimint", rev = "6a923ee10c3a578cd835044e3fdd94aa5123735a" }
+fedimint-mint-client = { git = "https://github.com/fedimint/fedimint", rev = "6a923ee10c3a578cd835044e3fdd94aa5123735a" }
 
 # The `console_error_panic_hook` crate provides better debugging of panics by
 # logging them with `console.error`. This is great for development, but requires

mutiny-wasm/src/error.rs

@@ -159,6 +159,8 @@ pub enum MutinyJsError {
     /// Payjoin configuration error
     #[error("Payjoin configuration failed.")]
     PayjoinConfigError,
+    #[error("Fedimint external note reissuance failed.")]
+    FedimintReissueFailed,
     /// Unknown error.
     #[error("Unknown Error")]
     UnknownError,
@@ -226,6 +228,7 @@ impl From<MutinyError> for MutinyJsError {
             MutinyError::PayjoinConfigError => MutinyJsError::PayjoinConfigError,
             MutinyError::PayjoinCreateRequest => MutinyJsError::PayjoinCreateRequest,
             MutinyError::PayjoinResponse(e) => MutinyJsError::PayjoinResponse(e.to_string()),
+            MutinyError::FedimintReissueFailed => MutinyJsError::FedimintReissueFailed,
         }
     }
 }

mutiny-wasm/src/lib.rs

@@ -23,6 +23,7 @@ use bitcoin::hashes::sha256;
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::{Address, Network, OutPoint, Transaction, Txid};
 use fedimint_core::{api::InviteCode, config::FederationId};
+use fedimint_mint_client::OOBNotes;
 use futures::lock::Mutex;
 use gloo_utils::format::JsValueSerdeExt;
 use hex_conservative::DisplayHex;
@@ -1023,6 +1024,17 @@ impl MutinyWallet {
         Ok(self.inner.sweep_federation_balance(amount).await?.into())
     }
 
+    pub async fn reissue_oob_notes(&self, oob_notes: String) -> Result<bool, MutinyJsError> {
+        let notes = OOBNotes::from_str(&oob_notes).map_err(|e| {
+            log_error!(
+                self.inner.logger,
+                "Error parsing federation `OOBNotes` ({oob_notes}): {e}"
+            );
+            MutinyJsError::InvalidArgumentsError
+        })?;
+        Ok(self.inner.reissue_oob_notes(notes).await?)
+    }
+
     /// Estimate the fee before trying to sweep from federation
     pub async fn estimate_sweep_federation_fee(
         &self,