fedimint_cli/

client.rs

#[cfg(test)]
mod tests;

use std::collections::BTreeMap;
use std::ffi;
use std::str::FromStr;
use std::time::{Duration, SystemTime, UNIX_EPOCH};

use anyhow::{Context, bail};
use bitcoin::address::NetworkUnchecked;
use bitcoin::{Network, secp256k1};
use clap::Subcommand;
use fedimint_bip39::Mnemonic;
use fedimint_client::backup::Metadata;
use fedimint_client::{Client, ClientHandleArc};
use fedimint_core::config::{ClientModuleConfig, FederationId};
use fedimint_core::core::{ModuleInstanceId, ModuleKind, OperationId};
use fedimint_core::encoding::Encodable;
use fedimint_core::{Amount, BitcoinAmountOrAll, TieredCounts, TieredMulti};
use fedimint_ln_client::cli::LnInvoiceResponse;
use fedimint_ln_client::{LightningClientModule, LnReceiveState, OutgoingLightningPayment};
use fedimint_logging::LOG_CLIENT;
use fedimint_mint_client::{
    MintClientModule, OOBNotes, SelectNotesWithAtleastAmount, SelectNotesWithExactAmount,
};
use fedimint_wallet_client::{WalletClientModule, WithdrawState};
use futures::StreamExt;
use itertools::Itertools;
use lightning_invoice::{Bolt11InvoiceDescription, Description};
use serde::{Deserialize, Serialize};
use serde_json::json;
use time::OffsetDateTime;
use time::format_description::well_known::iso8601;
use tracing::{debug, info, warn};

use crate::metadata_from_clap_cli;

#[derive(Debug, Clone)]
pub enum ModuleSelector {
    Id(ModuleInstanceId),
    Kind(ModuleKind),
}

impl ModuleSelector {
    pub fn resolve(&self, client: &Client) -> anyhow::Result<ModuleInstanceId> {
        Ok(match self {
            ModuleSelector::Id(id) => {
                client.get_module_client_dyn(*id)?;
                *id
            }
            ModuleSelector::Kind(kind) => client
                .get_first_instance(kind)
                .context("No module with this kind found")?,
        })
    }
}
#[derive(Debug, Clone, Serialize)]
pub enum ModuleStatus {
    Active,
    UnsupportedByClient,
}

#[derive(Serialize)]
struct ModuleInfo {
    kind: ModuleKind,
    id: u16,
    status: ModuleStatus,
}

impl FromStr for ModuleSelector {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(if s.chars().all(|ch| ch.is_ascii_digit()) {
            Self::Id(s.parse()?)
        } else {
            Self::Kind(ModuleKind::clone_from_str(s))
        })
    }
}

#[derive(Debug, Clone, Subcommand)]
pub enum ClientCmd {
    /// Display wallet info (holdings, tiers)
    Info,
    /// Reissue notes received from a third party to avoid double spends
    #[clap(hide = true)]
    Reissue {
        oob_notes: OOBNotes,
        #[arg(long = "no-wait", action = clap::ArgAction::SetFalse)]
        wait: bool,
    },
    /// Prepare notes to send to a third party as a payment
    #[clap(hide = true)]
    Spend {
        /// The amount of e-cash to spend
        amount: Amount,
        /// If the exact amount cannot be represented, return e-cash of a higher
        /// value instead of failing
        #[clap(long)]
        allow_overpay: bool,
        /// After how many seconds we will try to reclaim the e-cash if it
        /// hasn't been redeemed by the recipient. Defaults to one week.
        #[clap(long, default_value_t = 60 * 60 * 24 * 7)]
        timeout: u64,
        /// If the necessary information to join the federation the e-cash
        /// belongs to should be included in the serialized notes
        #[clap(long)]
        include_invite: bool,
    },
    /// Splits a string containing multiple e-cash notes (e.g. from the `spend`
    /// command) into ones that contain exactly one.
    #[clap(hide = true)]
    Split { oob_notes: OOBNotes },
    /// Combines two or more serialized e-cash notes strings
    #[clap(hide = true)]
    Combine {
        #[clap(required = true)]
        oob_notes: Vec<OOBNotes>,
    },
    /// Create a lightning invoice to receive payment via gateway
    #[clap(hide = true)]
    LnInvoice {
        #[clap(long)]
        amount: Amount,
        #[clap(long, default_value = "")]
        description: String,
        #[clap(long)]
        expiry_time: Option<u64>,
        #[clap(long)]
        gateway_id: Option<secp256k1::PublicKey>,
        #[clap(long, default_value = "false")]
        force_internal: bool,
    },
    /// Wait for incoming invoice to be paid
    #[clap(hide = true)]
    AwaitInvoice { operation_id: OperationId },
    /// Pay a lightning invoice or lnurl via a gateway
    #[clap(hide = true)]
    LnPay {
        /// Lightning invoice or lnurl
        payment_info: String,
        /// Amount to pay, used for lnurl
        #[clap(long)]
        amount: Option<Amount>,
        /// Invoice comment/description, used on lnurl
        #[clap(long)]
        lnurl_comment: Option<String>,
        #[clap(long)]
        gateway_id: Option<secp256k1::PublicKey>,
        #[clap(long, default_value = "false")]
        force_internal: bool,
    },
    /// Wait for a lightning payment to complete
    #[clap(hide = true)]
    AwaitLnPay { operation_id: OperationId },
    /// List registered gateways
    #[clap(hide = true)]
    ListGateways {
        /// Don't fetch the registered gateways from the federation
        #[clap(long, default_value = "false")]
        no_update: bool,
    },
    /// Generate a new deposit address, funds sent to it can later be claimed
    #[clap(hide = true)]
    DepositAddress,
    /// Wait for deposit on previously generated address
    #[clap(hide = true)]
    AwaitDeposit { operation_id: OperationId },
    /// Withdraw funds from the federation
    #[clap(hide = true)]
    Withdraw {
        #[clap(long)]
        amount: BitcoinAmountOrAll,
        #[clap(long)]
        address: bitcoin::Address<NetworkUnchecked>,
    },
    /// Upload the (encrypted) snapshot of mint notes to federation
    Backup {
        #[clap(long = "metadata")]
        /// Backup metadata, encoded as `key=value` (use `--metadata=key=value`,
        /// possibly multiple times)
        // TODO: Can we make it `*Map<String, String>` and avoid custom parsing?
        metadata: Vec<String>,
    },
    /// Discover the common api version to use to communicate with the
    /// federation
    #[clap(hide = true)]
    DiscoverVersion,
    /// Join federation and restore modules that support it
    Restore {
        /// BIP-39 mnemonic used by standard Fedimint CLI clients.
        ///
        /// If omitted, use global `--federation-secret-hex` instead.
        #[clap(long)]
        mnemonic: Option<String>,
        #[clap(long)]
        invite_code: String,
    },
    /// Print the secret key of the client
    PrintSecret,
    ListOperations {
        #[clap(long, default_value = "10")]
        limit: usize,
    },
    /// Call a module subcommand
    // Make `--help` be passed to the module handler, not root cli one
    #[command(disable_help_flag = true)]
    Module {
        /// Module selector (either module id or module kind)
        module: Option<ModuleSelector>,
        #[arg(allow_hyphen_values = true, trailing_var_arg = true)]
        args: Vec<ffi::OsString>,
    },
    /// Returns the client config
    #[clap(hide = true)]
    Config,
    /// Gets the current fedimint AlephBFT session count
    #[clap(hide = true)]
    SessionCount,
    /// Shows how available each guardian has been, as combined from all
    /// guardians' views of each other
    PeerAvailability,
}

/// Reissue legacy mint notes, optionally waiting for the operation stream.
async fn reissue_notes(
    client: &Client,
    oob_notes: OOBNotes,
    wait: bool,
) -> anyhow::Result<serde_json::Value> {
    warn!(
        target: LOG_CLIENT,
        "Command deprecated. Use `fedimint-cli module mint reissue` instead."
    );
    let amount = oob_notes.total_amount();

    let mint = client.get_first_module::<MintClientModule>()?;

    let operation_id = mint.reissue_external_notes(oob_notes, ()).await?;
    if wait {
        let mut updates = mint
            .subscribe_reissue_external_notes(operation_id)
            .await
            .expect("just created operation can't already be deleted")
            .into_stream();

        while let Some(update) = updates.next().await {
            if let fedimint_mint_client::ReissueExternalNotesState::Failed(e) = update {
                bail!("Reissue failed: {e}");
            }

            debug!(target: LOG_CLIENT, ?update, "Reissue external notes state update");
        }
    }

    Ok(serde_json::to_value(amount).expect("Amount is serializable"))
}

/// Select and spend legacy notes, preserving overpay and cancellation policy.
async fn spend_notes(
    client: &Client,
    amount: Amount,
    allow_overpay: bool,
    timeout: u64,
    include_invite: bool,
) -> anyhow::Result<serde_json::Value> {
    warn!(
        target: LOG_CLIENT,
        "Command deprecated. Use `fedimint-cli module mint spend` instead."
    );
    warn!(
        target: LOG_CLIENT,
        "The client will try to double-spend these notes after the duration specified by the --timeout option to recover any unclaimed e-cash."
    );

    let mint_module = client.get_first_module::<MintClientModule>()?;
    let timeout = Duration::from_secs(timeout);
    let (operation, notes) = if allow_overpay {
        let (operation, notes) = mint_module
            .spend_notes_with_selector(
                &SelectNotesWithAtleastAmount,
                amount,
                Some(timeout),
                include_invite,
                (),
            )
            .await?;

        let overspend_amount = notes.total_amount().saturating_sub(amount);
        if overspend_amount != Amount::ZERO {
            warn!(
                target: LOG_CLIENT,
                "Selected notes {} worth more than requested",
                overspend_amount
            );
        }

        (operation, notes)
    } else {
        mint_module
            .spend_notes_with_selector(
                &SelectNotesWithExactAmount,
                amount,
                Some(timeout),
                include_invite,
                (),
            )
            .await?
    };
    info!(target: LOG_CLIENT, "Spend e-cash operation: {}", operation.fmt_short());

    Ok(json!({
        "notes": notes,
    }))
}

/// Split legacy notes into individual notes grouped by denomination.
fn split_notes(oob_notes: &OOBNotes) -> serde_json::Value {
    warn!(
        target: LOG_CLIENT,
        "Command deprecated. Use `fedimint-cli module mint split` instead."
    );
    let federation = oob_notes.federation_id_prefix();
    let notes = oob_notes
        .notes()
        .iter()
        .map(|(amount, notes)| {
            let notes = notes
                .iter()
                .map(|note| {
                    OOBNotes::new(
                        federation,
                        TieredMulti::new(vec![(amount, vec![*note])].into_iter().collect()),
                    )
                })
                .collect::<Vec<_>>();
            (amount, notes)
        })
        .collect::<BTreeMap<_, _>>();

    json!({
        "notes": notes,
    })
}

/// Combine legacy notes only when all inputs belong to the same federation.
fn combine_notes(oob_notes: &[OOBNotes]) -> anyhow::Result<serde_json::Value> {
    warn!(
        target: LOG_CLIENT,
        "Command deprecated. Use `fedimint-cli module mint combine` instead."
    );
    let federation_id_prefix = match oob_notes
        .iter()
        .map(OOBNotes::federation_id_prefix)
        .all_equal_value()
    {
        Ok(id) => id,
        Err(None) => panic!("At least one e-cash notes string expected"),
        Err(Some((a, b))) => {
            bail!("Trying to combine e-cash from different federations: {a} and {b}");
        }
    };

    let combined_notes = oob_notes
        .iter()
        .flat_map(|notes| notes.notes().iter_items().map(|(amt, note)| (amt, *note)))
        .collect();

    let combined_oob_notes = OOBNotes::new(federation_id_prefix, combined_notes);

    Ok(json!({
        "notes": combined_oob_notes,
    }))
}

/// Create a legacy Lightning invoice through the selected gateway.
async fn create_invoice(
    client: &Client,
    amount: Amount,
    description: String,
    expiry_time: Option<u64>,
    gateway_id: Option<secp256k1::PublicKey>,
    force_internal: bool,
) -> anyhow::Result<serde_json::Value> {
    warn!(
        target: LOG_CLIENT,
        "Command deprecated. Use `fedimint-cli module ln invoice` instead."
    );
    let lightning_module = client.get_first_module::<LightningClientModule>()?;
    let ln_gateway = lightning_module
        .get_gateway(gateway_id, force_internal)
        .await?;

    let lightning_module = client.get_first_module::<LightningClientModule>()?;
    let desc = Description::new(description)?;
    let (operation_id, invoice, _) = lightning_module
        .create_bolt11_invoice(
            amount,
            Bolt11InvoiceDescription::Direct(desc),
            expiry_time,
            (),
            ln_gateway,
        )
        .await?;
    Ok(serde_json::to_value(LnInvoiceResponse {
        operation_id,
        invoice: invoice.to_string(),
    })
    .expect("LnInvoiceResponse is serializable"))
}

/// Wait for invoice receipt, preserving terminal stream outcomes.
async fn await_invoice(
    client: &ClientHandleArc,
    operation_id: OperationId,
) -> anyhow::Result<serde_json::Value> {
    warn!(
        target: LOG_CLIENT,
        "Command deprecated. Use `fedimint-cli module ln await-invoice` instead."
    );
    let lightning_module = &client.get_first_module::<LightningClientModule>()?;
    let mut updates = lightning_module
        .subscribe_ln_receive(operation_id)
        .await?
        .into_stream();
    while let Some(update) = updates.next().await {
        match update {
            LnReceiveState::Claimed => {
                return get_note_summary(client).await;
            }
            LnReceiveState::Canceled { reason } => {
                return Err(reason.into());
            }
            _ => {}
        }

        debug!(target: LOG_CLIENT, ?update, "Await invoice state update");
    }

    Err(anyhow::anyhow!(
        "Unexpected end of update stream. Lightning receive failed"
    ))
}

/// Pay a legacy Lightning invoice or LNURL and wait for its final outcome.
async fn pay_invoice(
    client: &Client,
    payment_info: String,
    amount: Option<Amount>,
    lnurl_comment: Option<String>,
    gateway_id: Option<secp256k1::PublicKey>,
    force_internal: bool,
) -> anyhow::Result<serde_json::Value> {
    warn!(
        target: LOG_CLIENT,
        "Command deprecated. Use `fedimint-cli module ln pay` instead."
    );
    let bolt11 = fedimint_ln_client::get_invoice(&payment_info, amount, lnurl_comment).await?;
    info!(target: LOG_CLIENT, "Paying invoice: {bolt11}");
    let lightning_module = client.get_first_module::<LightningClientModule>()?;
    let ln_gateway = lightning_module
        .get_gateway(gateway_id, force_internal)
        .await?;

    let lightning_module = client.get_first_module::<LightningClientModule>()?;
    let OutgoingLightningPayment {
        payment_type,
        contract_id: _,
        fee,
    } = lightning_module
        .pay_bolt11_invoice(ln_gateway, bolt11, ())
        .await?;
    let operation_id = payment_type.operation_id();
    info!(
        target: LOG_CLIENT,
        "Gateway fee: {fee}, payment operation id: {}",
        operation_id.fmt_short()
    );
    let lnv1 = client.get_first_module::<LightningClientModule>()?;
    let outcome = lnv1.await_outgoing_payment(operation_id).await?;
    Ok(serde_json::to_value(outcome).expect("Cant fail"))
}

/// Dispatch client commands using the already-open client.
pub async fn handle_command(
    command: ClientCmd,
    client: ClientHandleArc,
) -> anyhow::Result<serde_json::Value> {
    match command {
        ClientCmd::Info => get_note_summary(&client).await,
        ClientCmd::Reissue { oob_notes, wait } => reissue_notes(&client, oob_notes, wait).await,
        ClientCmd::Spend {
            amount,
            allow_overpay,
            timeout,
            include_invite,
        } => spend_notes(&client, amount, allow_overpay, timeout, include_invite).await,
        ClientCmd::Split { oob_notes } => Ok(split_notes(&oob_notes)),
        ClientCmd::Combine { oob_notes } => combine_notes(&oob_notes),
        ClientCmd::LnInvoice {
            amount,
            description,
            expiry_time,
            gateway_id,
            force_internal,
        } => {
            create_invoice(
                &client,
                amount,
                description,
                expiry_time,
                gateway_id,
                force_internal,
            )
            .await
        }
        ClientCmd::AwaitInvoice { operation_id } => await_invoice(&client, operation_id).await,
        ClientCmd::LnPay {
            payment_info,
            amount,
            lnurl_comment,
            gateway_id,
            force_internal,
        } => {
            pay_invoice(
                &client,
                payment_info,
                amount,
                lnurl_comment,
                gateway_id,
                force_internal,
            )
            .await
        }
        ClientCmd::AwaitLnPay { operation_id } => {
            warn!(
                target: LOG_CLIENT,
                "Command deprecated. Use `fedimint-cli module ln await-pay` instead."
            );
            let lightning_module = client.get_first_module::<LightningClientModule>()?;
            let outcome = lightning_module
                .await_outgoing_payment(operation_id)
                .await?;
            Ok(serde_json::to_value(outcome).expect("Cant fail"))
        }
        ClientCmd::ListGateways { no_update } => {
            warn!(
                target: LOG_CLIENT,
                "Command deprecated. Use `fedimint-cli module ln list-gateways` instead."
            );
            let lightning_module = client.get_first_module::<LightningClientModule>()?;
            if !no_update {
                lightning_module.update_gateway_cache().await?;
            }
            let gateways = lightning_module.list_gateways().await;
            if gateways.is_empty() {
                return Ok(
                    serde_json::to_value(Vec::<String>::new()).expect("empty vec is serializable")
                );
            }

            Ok(json!(&gateways))
        }
        ClientCmd::DepositAddress => {
            warn!(
                target: LOG_CLIENT,
                "Command deprecated. Use `fedimint-cli module wallet new-deposit-address` instead."
            );
            let deposit_address = client
                .get_first_module::<WalletClientModule>()?
                .allocate_deposit_address_expert_only(())
                .await?;
            Ok(serde_json::json! {
                {
                    "address": deposit_address.address,
                    "operation_id": deposit_address.operation_id,
                    "idx": deposit_address.tweak_idx.0
                }
            })
        }
        ClientCmd::AwaitDeposit { operation_id } => {
            warn!(
                target: LOG_CLIENT,
                "Command deprecated. Use `fedimint-cli module wallet await-deposit` instead."
            );
            client
                .get_first_module::<WalletClientModule>()?
                .await_num_deposits_by_operation_id(operation_id, 1)
                .await?;

            Ok(serde_json::to_value(()).expect("unit type is serializable"))
        }

        ClientCmd::Backup { metadata } => {
            let metadata = metadata_from_clap_cli(metadata)?;

            #[allow(deprecated)]
            client
                .backup_to_federation(Metadata::from_json_serialized(metadata))
                .await?;
            Ok(serde_json::to_value(()).expect("unit type is serializable"))
        }
        ClientCmd::Restore { .. } => {
            panic!("Has to be handled before initializing client")
        }
        ClientCmd::PrintSecret => {
            let entropy = client.get_decoded_client_secret::<Vec<u8>>().await?;
            let mnemonic = Mnemonic::from_entropy(&entropy)?;

            Ok(json!({
                "secret": mnemonic,
            }))
        }
        ClientCmd::ListOperations { limit } => {
            #[derive(Serialize)]
            #[serde(rename_all = "snake_case")]
            struct OperationOutput {
                id: OperationId,
                creation_time: String,
                operation_kind: String,
                operation_meta: serde_json::Value,
                #[serde(skip_serializing_if = "Option::is_none")]
                outcome: Option<serde_json::Value>,
            }

            let operations = client
                .operation_log()
                .paginate_operations_rev(limit, None)
                .await
                .into_iter()
                .map(|(k, v)| {
                    let creation_time = time_to_iso8601(&k.creation_time);

                    OperationOutput {
                        id: k.operation_id,
                        creation_time,
                        operation_kind: v.operation_module_kind().to_owned(),
                        operation_meta: v.meta(),
                        outcome: v.outcome(),
                    }
                })
                .collect::<Vec<_>>();

            Ok(json!({
                "operations": operations,
            }))
        }
        ClientCmd::Withdraw { amount, address } => withdraw(&client, amount, address).await,
        ClientCmd::DiscoverVersion => {
            Ok(json!({ "versions": client.load_and_refresh_common_api_version().await? }))
        }
        ClientCmd::Module { module, args } => {
            if let Some(module) = module {
                let module_instance_id = module.resolve(&client)?;

                Ok(client
                    .get_module_client_dyn(module_instance_id)
                    .context("Module not found")?
                    .handle_cli_command(&args)
                    .await?)
            } else {
                let module_list: Vec<ModuleInfo> = client
                    .config()
                    .await
                    .modules
                    .iter()
                    .map(|(id, ClientModuleConfig { kind, .. })| ModuleInfo {
                        kind: kind.clone(),
                        id: *id,
                        status: if client.has_module(*id) {
                            ModuleStatus::Active
                        } else {
                            ModuleStatus::UnsupportedByClient
                        },
                    })
                    .collect();
                Ok(json!({
                    "list": module_list,
                }))
            }
        }
        ClientCmd::Config => {
            warn!(
                target: LOG_CLIENT,
                "Command deprecated. Use `fedimint-cli dev config` instead."
            );
            let config = client.get_config_json().await;
            Ok(serde_json::to_value(config).expect("Client config is serializable"))
        }
        ClientCmd::SessionCount => {
            warn!(
                target: LOG_CLIENT,
                "Command deprecated. Use `fedimint-cli dev session-count` instead."
            );
            let count = client.api().session_count().await?;
            Ok(json!({ "count": count }))
        }
        ClientCmd::PeerAvailability => Ok(serde_json::to_value(client.peer_availability().await)
            .expect("Peer availability is serializable")),
    }
}

/// Quote and execute a legacy withdrawal, keeping its amount and fees paired.
async fn withdraw(
    client: &Client,
    amount: BitcoinAmountOrAll,
    address: bitcoin::Address<NetworkUnchecked>,
) -> anyhow::Result<serde_json::Value> {
    warn!(
        target: LOG_CLIENT,
        "Command deprecated. Use `fedimint-cli module wallet withdraw` instead."
    );
    let wallet_module = client.get_first_module::<WalletClientModule>()?;
    let address = address.require_network(wallet_module.get_network())?;
    let (amount, fees) = match amount {
        // The on-chain fee is only part of the cost of withdrawing
        // everything: funding the peg-out output also incurs the
        // federation's per-note fees. The returned fees are quoted at
        // the returned amount, so they must be used together.
        BitcoinAmountOrAll::All => {
            let balance = client.get_balance_for_btc().await?;
            wallet_module
                .max_withdrawable_amount(&address, balance)
                .await?
        }
        BitcoinAmountOrAll::Amount(amount) => (
            amount,
            wallet_module.get_withdraw_fees(&address, amount).await?,
        ),
    };
    let absolute_fees = fees.amount();
    info!(
        target: LOG_CLIENT,
        "Attempting withdraw with fees: {fees:?}"
    );
    let operation_id = wallet_module.withdraw(&address, amount, fees, ()).await?;
    let mut updates = wallet_module
        .subscribe_withdraw_updates(operation_id)
        .await?
        .into_stream();
    while let Some(update) = updates.next().await {
        debug!(target: LOG_CLIENT, ?update, "Withdraw state update");
        match update {
            WithdrawState::Succeeded(txid) => {
                return Ok(json!({
                    "txid": txid.consensus_encode_to_hex(),
                    "fees_sat": absolute_fees.to_sat(),
                }));
            }
            WithdrawState::Failed(e) => bail!("Withdraw failed: {e}"),
            WithdrawState::Created => {}
        }
    }
    unreachable!("Update stream ended without outcome");
}

async fn get_note_summary(client: &ClientHandleArc) -> anyhow::Result<serde_json::Value> {
    // Try wallet v1 first, then walletv2
    let network = if let Ok(wallet_client) = client.get_first_module::<WalletClientModule>() {
        wallet_client.get_network()
    } else if let Ok(wallet_client) =
        client.get_first_module::<fedimint_walletv2_client::WalletClientModule>()
    {
        wallet_client.get_network()
    } else {
        anyhow::bail!("No wallet module found");
    };

    let summary = if let Ok(mint_client) = client.get_first_module::<MintClientModule>() {
        let mint_module_id = client
            .get_first_instance(&fedimint_mint_client::KIND)
            .context("Mint module not found")?;
        mint_client
            .get_note_counts_by_denomination(
                &mut client
                    .db()
                    .begin_transaction_nc()
                    .await
                    .to_ref_with_prefix_module_id(mint_module_id)
                    .0,
            )
            .await
    } else if let Ok(mintv2_client) =
        client.get_first_module::<fedimint_mintv2_client::MintClientModule>()
    {
        let counts = mintv2_client.get_count_by_denomination().await;
        let mut summary = TieredCounts::default();
        #[allow(clippy::cast_possible_truncation)]
        for (denomination, count) in counts {
            summary.inc(denomination.amount(), count as usize);
        }
        summary
    } else {
        anyhow::bail!("No mint module found");
    };

    Ok(serde_json::to_value(InfoResponse {
        federation_id: client.federation_id(),
        network,
        meta: client.config().await.global.meta.clone(),
        total_amount_msat: summary.total_amount(),
        total_num_notes: summary.count_items(),
        denominations_msat: summary,
    })
    .expect("InfoResponse is serializable"))
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub struct InfoResponse {
    federation_id: FederationId,
    network: Network,
    meta: BTreeMap<String, String>,
    total_amount_msat: Amount,
    total_num_notes: usize,
    denominations_msat: TieredCounts,
}

pub(crate) fn time_to_iso8601(time: &SystemTime) -> String {
    const ISO8601_CONFIG: iso8601::EncodedConfig = iso8601::Config::DEFAULT
        .set_formatted_components(iso8601::FormattedComponents::DateTime)
        .encode();

    OffsetDateTime::from_unix_timestamp_nanos(
        time.duration_since(UNIX_EPOCH)
            .expect("Couldn't convert time from SystemTime to timestamp")
            .as_nanos()
            .try_into()
            .expect("Time overflowed"),
    )
    .expect("Couldn't convert time from SystemTime to OffsetDateTime")
    .format(&iso8601::Iso8601::<ISO8601_CONFIG>)
    .expect("Couldn't format OffsetDateTime as ISO8601")
}