cdk/crates/cdk-redb/src/mint/mod.rs

//! SQLite Storage for CDK

use std::cmp::Ordering;
use std::collections::{HashMap, HashSet};
use std::path::Path;
use std::str::FromStr;
use std::sync::Arc;

use async_trait::async_trait;
use cdk_common::common::{PaymentProcessorKey, QuoteTTL};
use cdk_common::database::{
    self, MintDatabase, MintKeysDatabase, MintProofsDatabase, MintQuotesDatabase,
    MintSignaturesDatabase,
};
use cdk_common::dhke::hash_to_curve;
use cdk_common::mint::{self, MintKeySetInfo, MintQuote};
use cdk_common::nut00::ProofsMethods;
use cdk_common::util::unix_time;
use cdk_common::{
    BlindSignature, CurrencyUnit, Id, MeltBolt11Request, MeltQuoteState, MintInfo, MintQuoteState,
    Proof, Proofs, PublicKey, State,
};
use migrations::{migrate_01_to_02, migrate_04_to_05};
use redb::{Database, MultimapTableDefinition, ReadableTable, TableDefinition};
use uuid::Uuid;

use super::error::Error;
use crate::migrations::migrate_00_to_01;
use crate::mint::migrations::{migrate_02_to_03, migrate_03_to_04};

#[cfg(feature = "auth")]
mod auth;
mod migrations;

#[cfg(feature = "auth")]
pub use auth::MintRedbAuthDatabase;

const ACTIVE_KEYSETS_TABLE: TableDefinition<&str, &str> = TableDefinition::new("active_keysets");
const KEYSETS_TABLE: TableDefinition<&str, &str> = TableDefinition::new("keysets");
const MINT_QUOTES_TABLE: TableDefinition<[u8; 16], &str> = TableDefinition::new("mint_quotes");
const MELT_QUOTES_TABLE: TableDefinition<[u8; 16], &str> = TableDefinition::new("melt_quotes");
const PROOFS_TABLE: TableDefinition<[u8; 33], &str> = TableDefinition::new("proofs");
const PROOFS_STATE_TABLE: TableDefinition<[u8; 33], &str> = TableDefinition::new("proofs_state");
const PROOF_CREATED_TIME: TableDefinition<[u8; 33], u64> =
    TableDefinition::new("proof_created_time");
const CONFIG_TABLE: TableDefinition<&str, &str> = TableDefinition::new("config");
// Key is hex blinded_message B_ value is blinded_signature
const BLINDED_SIGNATURES: TableDefinition<[u8; 33], &str> =
    TableDefinition::new("blinded_signatures");
const BLIND_SIGNATURE_CREATED_TIME: TableDefinition<[u8; 33], u64> =
    TableDefinition::new("blind_signature_created_time");
const QUOTE_PROOFS_TABLE: MultimapTableDefinition<[u8; 16], [u8; 33]> =
    MultimapTableDefinition::new("quote_proofs");
const QUOTE_SIGNATURES_TABLE: MultimapTableDefinition<[u8; 16], [u8; 33]> =
    MultimapTableDefinition::new("quote_signatures");

const MELT_REQUESTS: TableDefinition<[u8; 16], (&str, &str)> =
    TableDefinition::new("melt_requests");

const DATABASE_VERSION: u32 = 5;

/// Mint Redbdatabase
#[derive(Debug, Clone)]
pub struct MintRedbDatabase {
    db: Arc<Database>,
}

impl MintRedbDatabase {
    /// Create new [`MintRedbDatabase`]
    pub fn new(path: &Path) -> Result<Self, Error> {
        {
            // Check database version

            let db = Arc::new(Database::create(path)?);

            // Check database version
            let read_txn = db.begin_read()?;
            let table = read_txn.open_table(CONFIG_TABLE);

            let db_version = match table {
                Ok(table) => table.get("db_version")?.map(|v| v.value().to_owned()),
                Err(_) => None,
            };
            match db_version {
                Some(db_version) => {
                    let mut current_file_version = u32::from_str(&db_version)?;
                    match current_file_version.cmp(&DATABASE_VERSION) {
                        Ordering::Less => {
                            tracing::info!(
                                "Database needs to be upgraded at {} current is {}",
                                current_file_version,
                                DATABASE_VERSION
                            );
                            if current_file_version == 0 {
                                current_file_version = migrate_00_to_01(Arc::clone(&db))?;
                            }

                            if current_file_version == 1 {
                                current_file_version = migrate_01_to_02(Arc::clone(&db))?;
                            }

                            if current_file_version == 2 {
                                current_file_version = migrate_02_to_03(Arc::clone(&db))?;
                            }

                            if current_file_version == 3 {
                                current_file_version = migrate_03_to_04(Arc::clone(&db))?;
                            }

                            if current_file_version == 4 {
                                current_file_version = migrate_04_to_05(Arc::clone(&db))?;
                            }

                            if current_file_version != DATABASE_VERSION {
                                tracing::warn!(
                                    "Database upgrade did not complete at {} current is {}",
                                    current_file_version,
                                    DATABASE_VERSION
                                );
                                return Err(Error::UnknownDatabaseVersion);
                            }

                            let write_txn = db.begin_write()?;
                            {
                                let mut table = write_txn.open_table(CONFIG_TABLE)?;

                                table
                                    .insert("db_version", DATABASE_VERSION.to_string().as_str())?;
                            }

                            write_txn.commit()?;
                        }
                        Ordering::Equal => {
                            tracing::info!("Database is at current version {}", DATABASE_VERSION);
                        }
                        Ordering::Greater => {
                            tracing::warn!(
                                "Database upgrade did not complete at {} current is {}",
                                current_file_version,
                                DATABASE_VERSION
                            );
                            return Err(Error::UnknownDatabaseVersion);
                        }
                    }
                }
                None => {
                    let write_txn = db.begin_write()?;
                    {
                        // Open all tables to init a new db
                        let mut table = write_txn.open_table(CONFIG_TABLE)?;
                        let _ = write_txn.open_table(ACTIVE_KEYSETS_TABLE)?;
                        let _ = write_txn.open_table(KEYSETS_TABLE)?;
                        let _ = write_txn.open_table(MINT_QUOTES_TABLE)?;
                        let _ = write_txn.open_table(MELT_QUOTES_TABLE)?;
                        let _ = write_txn.open_table(PROOFS_TABLE)?;
                        let _ = write_txn.open_table(PROOFS_STATE_TABLE)?;
                        let _ = write_txn.open_table(PROOF_CREATED_TIME)?;
                        let _ = write_txn.open_table(BLINDED_SIGNATURES)?;
                        let _ = write_txn.open_table(BLIND_SIGNATURE_CREATED_TIME)?;
                        let _ = write_txn.open_multimap_table(QUOTE_PROOFS_TABLE)?;
                        let _ = write_txn.open_multimap_table(QUOTE_SIGNATURES_TABLE)?;

                        table.insert("db_version", DATABASE_VERSION.to_string().as_str())?;
                    }

                    write_txn.commit()?;
                }
            }
            drop(db);
        }

        let db = Database::create(path)?;
        Ok(Self { db: Arc::new(db) })
    }
}

#[async_trait]
impl MintKeysDatabase for MintRedbDatabase {
    type Err = database::Error;

    async fn set_active_keyset(&self, unit: CurrencyUnit, id: Id) -> Result<(), Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        {
            let mut table = write_txn
                .open_table(ACTIVE_KEYSETS_TABLE)
                .map_err(Error::from)?;
            table
                .insert(unit.to_string().as_str(), id.to_string().as_str())
                .map_err(Error::from)?;
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(())
    }

    async fn get_active_keyset_id(&self, unit: &CurrencyUnit) -> Result<Option<Id>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn
            .open_table(ACTIVE_KEYSETS_TABLE)
            .map_err(Error::from)?;

        if let Some(id) = table.get(unit.to_string().as_str()).map_err(Error::from)? {
            return Ok(Some(Id::from_str(id.value()).map_err(Error::from)?));
        }

        Ok(None)
    }

    async fn get_active_keysets(&self) -> Result<HashMap<CurrencyUnit, Id>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn
            .open_table(ACTIVE_KEYSETS_TABLE)
            .map_err(Error::from)?;

        let mut active_keysets = HashMap::new();

        for (unit, id) in (table.iter().map_err(Error::from)?).flatten() {
            let unit = CurrencyUnit::from_str(unit.value())?;
            let id = Id::from_str(id.value()).map_err(Error::from)?;

            active_keysets.insert(unit, id);
        }

        Ok(active_keysets)
    }

    async fn add_keyset_info(&self, keyset: MintKeySetInfo) -> Result<(), Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        {
            let mut table = write_txn.open_table(KEYSETS_TABLE).map_err(Error::from)?;
            table
                .insert(
                    keyset.id.to_string().as_str(),
                    serde_json::to_string(&keyset)
                        .map_err(Error::from)?
                        .as_str(),
                )
                .map_err(Error::from)?;
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(())
    }

    async fn get_keyset_info(&self, keyset_id: &Id) -> Result<Option<MintKeySetInfo>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn.open_table(KEYSETS_TABLE).map_err(Error::from)?;

        match table
            .get(keyset_id.to_string().as_str())
            .map_err(Error::from)?
        {
            Some(keyset) => Ok(serde_json::from_str(keyset.value()).map_err(Error::from)?),
            None => Ok(None),
        }
    }

    async fn get_keyset_infos(&self) -> Result<Vec<MintKeySetInfo>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn.open_table(KEYSETS_TABLE).map_err(Error::from)?;

        let mut keysets = Vec::new();

        for (_id, keyset) in (table.iter().map_err(Error::from)?).flatten() {
            let keyset = serde_json::from_str(keyset.value()).map_err(Error::from)?;

            keysets.push(keyset)
        }

        Ok(keysets)
    }
}

#[async_trait]
impl MintQuotesDatabase for MintRedbDatabase {
    type Err = database::Error;

    async fn add_mint_quote(&self, quote: MintQuote) -> Result<(), Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        {
            let mut table = write_txn
                .open_table(MINT_QUOTES_TABLE)
                .map_err(Error::from)?;
            table
                .insert(
                    quote.id.as_bytes(),
                    serde_json::to_string(&quote).map_err(Error::from)?.as_str(),
                )
                .map_err(Error::from)?;
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(())
    }

    async fn get_mint_quote(&self, quote_id: &Uuid) -> Result<Option<MintQuote>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn
            .open_table(MINT_QUOTES_TABLE)
            .map_err(Error::from)?;

        match table.get(quote_id.as_bytes()).map_err(Error::from)? {
            Some(quote) => Ok(serde_json::from_str(quote.value()).map_err(Error::from)?),
            None => Ok(None),
        }
    }

    async fn update_mint_quote_state(
        &self,
        quote_id: &Uuid,
        state: MintQuoteState,
    ) -> Result<MintQuoteState, Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        let current_state;
        {
            let mut mint_quote: MintQuote;
            let mut table = write_txn
                .open_table(MINT_QUOTES_TABLE)
                .map_err(Error::from)?;
            {
                let quote_guard = table
                    .get(quote_id.as_bytes())
                    .map_err(Error::from)?
                    .ok_or(Error::UnknownQuote)?;

                let quote = quote_guard.value();

                mint_quote = serde_json::from_str(quote).map_err(Error::from)?;
            }

            current_state = mint_quote.state;
            mint_quote.state = state;

            {
                table
                    .insert(
                        quote_id.as_bytes(),
                        serde_json::to_string(&mint_quote)
                            .map_err(Error::from)?
                            .as_str(),
                    )
                    .map_err(Error::from)?;
            }
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(current_state)
    }
    async fn get_mint_quote_by_request(
        &self,
        request: &str,
    ) -> Result<Option<MintQuote>, Self::Err> {
        let quotes = self.get_mint_quotes().await?;

        let quote = quotes
            .into_iter()
            .filter(|q| q.request.eq(request))
            .collect::<Vec<MintQuote>>()
            .first()
            .cloned();

        Ok(quote)
    }

    async fn get_mint_quote_by_request_lookup_id(
        &self,
        request_lookup_id: &str,
    ) -> Result<Option<MintQuote>, Self::Err> {
        let quotes = self.get_mint_quotes().await?;

        let quote = quotes
            .into_iter()
            .filter(|q| q.request_lookup_id.eq(request_lookup_id))
            .collect::<Vec<MintQuote>>()
            .first()
            .cloned();

        Ok(quote)
    }

    async fn get_mint_quotes(&self) -> Result<Vec<MintQuote>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn
            .open_table(MINT_QUOTES_TABLE)
            .map_err(Error::from)?;

        let mut quotes = Vec::new();

        for (_id, quote) in (table.iter().map_err(Error::from)?).flatten() {
            let quote = serde_json::from_str(quote.value()).map_err(Error::from)?;

            quotes.push(quote)
        }

        Ok(quotes)
    }

    async fn get_mint_quotes_with_state(
        &self,
        state: MintQuoteState,
    ) -> Result<Vec<MintQuote>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn
            .open_table(MINT_QUOTES_TABLE)
            .map_err(Error::from)?;

        let mut quotes = Vec::new();

        for (_id, quote) in (table.iter().map_err(Error::from)?).flatten() {
            let quote: MintQuote = serde_json::from_str(quote.value()).map_err(Error::from)?;

            if quote.state == state {
                quotes.push(quote)
            }
        }

        Ok(quotes)
    }

    async fn remove_mint_quote(&self, quote_id: &Uuid) -> Result<(), Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        {
            let mut table = write_txn
                .open_table(MINT_QUOTES_TABLE)
                .map_err(Error::from)?;
            table.remove(quote_id.as_bytes()).map_err(Error::from)?;
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(())
    }

    async fn add_melt_quote(&self, quote: mint::MeltQuote) -> Result<(), Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        {
            let mut table = write_txn
                .open_table(MELT_QUOTES_TABLE)
                .map_err(Error::from)?;
            table
                .insert(
                    quote.id.as_bytes(),
                    serde_json::to_string(&quote).map_err(Error::from)?.as_str(),
                )
                .map_err(Error::from)?;
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(())
    }

    async fn get_melt_quote(&self, quote_id: &Uuid) -> Result<Option<mint::MeltQuote>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn
            .open_table(MELT_QUOTES_TABLE)
            .map_err(Error::from)?;

        let quote = table.get(quote_id.as_bytes()).map_err(Error::from)?;

        Ok(quote.map(|q| serde_json::from_str(q.value()).unwrap()))
    }

    async fn update_melt_quote_state(
        &self,
        quote_id: &Uuid,
        state: MeltQuoteState,
    ) -> Result<MeltQuoteState, Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        let current_state;
        {
            let mut melt_quote: mint::MeltQuote;
            let mut table = write_txn
                .open_table(MELT_QUOTES_TABLE)
                .map_err(Error::from)?;
            {
                let quote_guard = table
                    .get(quote_id.as_bytes())
                    .map_err(Error::from)?
                    .ok_or(Error::UnknownQuote)?;

                let quote = quote_guard.value();

                melt_quote = serde_json::from_str(quote).map_err(Error::from)?;
            }

            current_state = melt_quote.state;
            melt_quote.state = state;

            {
                table
                    .insert(
                        quote_id.as_bytes(),
                        serde_json::to_string(&melt_quote)
                            .map_err(Error::from)?
                            .as_str(),
                    )
                    .map_err(Error::from)?;
            }
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(current_state)
    }

    async fn get_melt_quotes(&self) -> Result<Vec<mint::MeltQuote>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn
            .open_table(MELT_QUOTES_TABLE)
            .map_err(Error::from)?;

        let mut quotes = Vec::new();

        for (_id, quote) in (table.iter().map_err(Error::from)?).flatten() {
            let quote = serde_json::from_str(quote.value()).map_err(Error::from)?;

            quotes.push(quote)
        }

        Ok(quotes)
    }

    async fn remove_melt_quote(&self, quote_id: &Uuid) -> Result<(), Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        {
            let mut table = write_txn
                .open_table(MELT_QUOTES_TABLE)
                .map_err(Error::from)?;
            table.remove(quote_id.as_bytes()).map_err(Error::from)?;
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(())
    }

    /// Add melt request
    async fn add_melt_request(
        &self,
        melt_request: MeltBolt11Request<Uuid>,
        ln_key: PaymentProcessorKey,
    ) -> Result<(), Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;
        let mut table = write_txn.open_table(MELT_REQUESTS).map_err(Error::from)?;

        table
            .insert(
                melt_request.quote().as_bytes(),
                (
                    serde_json::to_string(&melt_request)?.as_str(),
                    serde_json::to_string(&ln_key)?.as_str(),
                ),
            )
            .map_err(Error::from)?;

        Ok(())
    }
    /// Get melt request
    async fn get_melt_request(
        &self,
        quote_id: &Uuid,
    ) -> Result<Option<(MeltBolt11Request<Uuid>, PaymentProcessorKey)>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn.open_table(MELT_REQUESTS).map_err(Error::from)?;

        match table.get(quote_id.as_bytes()).map_err(Error::from)? {
            Some(melt_request) => {
                let (melt_request_str, ln_key_str) = melt_request.value();
                let melt_request = serde_json::from_str(melt_request_str)?;
                let ln_key = serde_json::from_str(ln_key_str)?;

                Ok(Some((melt_request, ln_key)))
            }
            None => Ok(None),
        }
    }
}

#[async_trait]
impl MintProofsDatabase for MintRedbDatabase {
    type Err = database::Error;

    async fn add_proofs(&self, proofs: Proofs, quote_id: Option<Uuid>) -> Result<(), Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        {
            let mut table = write_txn.open_table(PROOFS_TABLE).map_err(Error::from)?;
            let mut time_table = write_txn
                .open_table(PROOF_CREATED_TIME)
                .map_err(Error::from)?;
            let mut quote_proofs_table = write_txn
                .open_multimap_table(QUOTE_PROOFS_TABLE)
                .map_err(Error::from)?;

            // Get current timestamp in seconds
            let current_time = unix_time();

            for proof in proofs {
                let y: PublicKey = hash_to_curve(&proof.secret.to_bytes()).map_err(Error::from)?;
                let y = y.to_bytes();
                if table.get(y).map_err(Error::from)?.is_none() {
                    table
                        .insert(
                            y,
                            serde_json::to_string(&proof).map_err(Error::from)?.as_str(),
                        )
                        .map_err(Error::from)?;

                    // Store creation time
                    time_table.insert(y, current_time).map_err(Error::from)?;
                }

                if let Some(quote_id) = &quote_id {
                    quote_proofs_table
                        .insert(quote_id.as_bytes(), y)
                        .map_err(Error::from)?;
                }
            }
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(())
    }

    async fn remove_proofs(
        &self,
        ys: &[PublicKey],
        quote_id: Option<Uuid>,
    ) -> Result<(), Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        let mut states: HashSet<State> = HashSet::new();

        {
            let mut proof_state_table = write_txn
                .open_table(PROOFS_STATE_TABLE)
                .map_err(Error::from)?;
            for y in ys {
                let state = proof_state_table
                    .remove(&y.to_bytes())
                    .map_err(Error::from)?;

                if let Some(state) = state {
                    let state: State = serde_json::from_str(state.value()).map_err(Error::from)?;

                    states.insert(state);
                }
            }
        }

        if states.contains(&State::Spent) {
            tracing::warn!("Db attempted to remove spent proof");
            write_txn.abort().map_err(Error::from)?;
            return Err(Self::Err::AttemptRemoveSpentProof);
        }

        {
            let mut proofs_table = write_txn.open_table(PROOFS_TABLE).map_err(Error::from)?;
            let mut time_table = write_txn
                .open_table(PROOF_CREATED_TIME)
                .map_err(Error::from)?;

            for y in ys {
                proofs_table.remove(&y.to_bytes()).map_err(Error::from)?;
                time_table.remove(&y.to_bytes()).map_err(Error::from)?;
            }
        }

        if let Some(quote_id) = quote_id {
            let mut quote_proofs_table = write_txn
                .open_multimap_table(QUOTE_PROOFS_TABLE)
                .map_err(Error::from)?;

            quote_proofs_table
                .remove_all(quote_id.as_bytes())
                .map_err(Error::from)?;
        }

        write_txn.commit().map_err(Error::from)?;

        Ok(())
    }

    async fn get_proofs_by_ys(&self, ys: &[PublicKey]) -> Result<Vec<Option<Proof>>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn.open_table(PROOFS_TABLE).map_err(Error::from)?;

        let mut proofs = Vec::with_capacity(ys.len());

        for y in ys {
            match table.get(y.to_bytes()).map_err(Error::from)? {
                Some(proof) => proofs.push(Some(
                    serde_json::from_str(proof.value()).map_err(Error::from)?,
                )),
                None => proofs.push(None),
            }
        }

        Ok(proofs)
    }

    async fn get_proof_ys_by_quote_id(&self, quote_id: &Uuid) -> Result<Vec<PublicKey>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn
            .open_multimap_table(QUOTE_PROOFS_TABLE)
            .map_err(Error::from)?;

        let ys = table.get(quote_id.as_bytes()).map_err(Error::from)?;

        let proof_ys = ys.fold(Vec::new(), |mut acc, y| {
            if let Ok(y) = y {
                if let Ok(pubkey) = PublicKey::from_slice(&y.value()) {
                    acc.push(pubkey);
                }
            }
            acc
        });

        Ok(proof_ys)
    }

    async fn get_proofs_states(&self, ys: &[PublicKey]) -> Result<Vec<Option<State>>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn
            .open_table(PROOFS_STATE_TABLE)
            .map_err(Error::from)?;

        let mut states = Vec::with_capacity(ys.len());

        for y in ys {
            match table.get(y.to_bytes()).map_err(Error::from)? {
                Some(state) => states.push(Some(
                    serde_json::from_str(state.value()).map_err(Error::from)?,
                )),
                None => states.push(None),
            }
        }

        Ok(states)
    }

    async fn get_proofs_by_keyset_id(
        &self,
        keyset_id: &Id,
    ) -> Result<(Proofs, Vec<Option<State>>), Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn.open_table(PROOFS_TABLE).map_err(Error::from)?;

        let proofs_for_id = table
            .iter()
            .map_err(Error::from)?
            .flatten()
            .map(|(_, p)| serde_json::from_str::<Proof>(p.value()))
            .collect::<Result<Proofs, _>>()?
            .into_iter()
            .filter(|p| &p.keyset_id == keyset_id)
            .collect::<Proofs>();

        let proof_ys = proofs_for_id.ys()?;

        assert_eq!(proofs_for_id.len(), proof_ys.len());

        let states = self.get_proofs_states(&proof_ys).await?;

        Ok((proofs_for_id, states))
    }

    async fn update_proofs_states(
        &self,
        ys: &[PublicKey],
        proofs_state: State,
    ) -> Result<Vec<Option<State>>, Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        let mut states = Vec::with_capacity(ys.len());
        {
            let table = write_txn
                .open_table(PROOFS_STATE_TABLE)
                .map_err(Error::from)?;
            {
                // First collect current states
                for y in ys {
                    let current_state = match table.get(y.to_bytes()).map_err(Error::from)? {
                        Some(state) => {
                            Some(serde_json::from_str(state.value()).map_err(Error::from)?)
                        }
                        None => None,
                    };
                    states.push(current_state);
                }
            }
        }

        // Check if any proofs are spent
        if states.contains(&Some(State::Spent)) {
            write_txn.abort().map_err(Error::from)?;
            return Err(database::Error::AttemptUpdateSpentProof);
        }

        {
            let mut table = write_txn
                .open_table(PROOFS_STATE_TABLE)
                .map_err(Error::from)?;
            {
                // If no proofs are spent, proceed with update
                let state_str = serde_json::to_string(&proofs_state).map_err(Error::from)?;
                for y in ys {
                    table
                        .insert(y.to_bytes(), state_str.as_str())
                        .map_err(Error::from)?;
                }
            }
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(states)
    }
}

#[async_trait]
impl MintSignaturesDatabase for MintRedbDatabase {
    type Err = database::Error;

    async fn add_blind_signatures(
        &self,
        blinded_messages: &[PublicKey],
        blind_signatures: &[BlindSignature],
        quote_id: Option<Uuid>,
    ) -> Result<(), Self::Err> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        {
            let mut table = write_txn
                .open_table(BLINDED_SIGNATURES)
                .map_err(Error::from)?;
            let mut time_table = write_txn
                .open_table(BLIND_SIGNATURE_CREATED_TIME)
                .map_err(Error::from)?;
            let mut quote_sigs_table = write_txn
                .open_multimap_table(QUOTE_SIGNATURES_TABLE)
                .map_err(Error::from)?;

            // Get current timestamp in seconds
            let current_time = unix_time();

            for (blinded_message, blind_signature) in blinded_messages.iter().zip(blind_signatures)
            {
                let blind_sig = serde_json::to_string(&blind_signature).map_err(Error::from)?;
                table
                    .insert(blinded_message.to_bytes(), blind_sig.as_str())
                    .map_err(Error::from)?;

                // Store creation time
                time_table
                    .insert(blinded_message.to_bytes(), current_time)
                    .map_err(Error::from)?;

                if let Some(quote_id) = &quote_id {
                    quote_sigs_table
                        .insert(quote_id.as_bytes(), blinded_message.to_bytes())
                        .map_err(Error::from)?;
                }
            }
        }

        write_txn.commit().map_err(Error::from)?;

        Ok(())
    }

    async fn get_blind_signatures(
        &self,
        blinded_messages: &[PublicKey],
    ) -> Result<Vec<Option<BlindSignature>>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn
            .open_table(BLINDED_SIGNATURES)
            .map_err(Error::from)?;

        let mut signatures = Vec::with_capacity(blinded_messages.len());

        for blinded_message in blinded_messages {
            match table.get(blinded_message.to_bytes()).map_err(Error::from)? {
                Some(blind_signature) => signatures.push(Some(
                    serde_json::from_str(blind_signature.value()).map_err(Error::from)?,
                )),
                None => signatures.push(None),
            }
        }

        Ok(signatures)
    }

    async fn get_blind_signatures_for_keyset(
        &self,
        keyset_id: &Id,
    ) -> Result<Vec<BlindSignature>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn
            .open_table(BLINDED_SIGNATURES)
            .map_err(Error::from)?;

        Ok(table
            .iter()
            .map_err(Error::from)?
            .flatten()
            .filter_map(|(_m, s)| {
                match serde_json::from_str::<BlindSignature>(s.value()).ok() {
                    Some(signature) if &signature.keyset_id == keyset_id => Some(signature), // Filter by keyset_id
                    _ => None, // Exclude non-matching entries
                }
            })
            .collect())
    }

    /// Get [`BlindSignature`]s for quote
    async fn get_blind_signatures_for_quote(
        &self,
        quote_id: &Uuid,
    ) -> Result<Vec<BlindSignature>, Self::Err> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let quote_proofs_table = read_txn
            .open_multimap_table(QUOTE_SIGNATURES_TABLE)
            .map_err(Error::from)?;

        let ys = quote_proofs_table.get(quote_id.as_bytes()).unwrap();

        let ys: Vec<[u8; 33]> = ys.into_iter().flatten().map(|v| v.value()).collect();

        let mut signatures = Vec::new();

        let signatures_table = read_txn
            .open_table(BLINDED_SIGNATURES)
            .map_err(Error::from)?;

        for y in ys {
            if let Some(sig) = signatures_table.get(y).map_err(Error::from)? {
                let sig = serde_json::from_str(sig.value())?;
                signatures.push(sig);
            }
        }

        Ok(signatures)
    }
}

#[async_trait]
impl MintDatabase<database::Error> for MintRedbDatabase {
    async fn set_mint_info(&self, mint_info: MintInfo) -> Result<(), database::Error> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        {
            let mut table = write_txn.open_table(CONFIG_TABLE).map_err(Error::from)?;
            table
                .insert("mint_info", serde_json::to_string(&mint_info)?.as_str())
                .map_err(Error::from)?;
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(())
    }
    async fn get_mint_info(&self) -> Result<MintInfo, database::Error> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn.open_table(CONFIG_TABLE).map_err(Error::from)?;

        if let Some(mint_info) = table.get("mint_info").map_err(Error::from)? {
            let mint_info = serde_json::from_str(mint_info.value())?;

            return Ok(mint_info);
        }

        Err(Error::UnknownMintInfo.into())
    }

    async fn set_quote_ttl(&self, quote_ttl: QuoteTTL) -> Result<(), database::Error> {
        let write_txn = self.db.begin_write().map_err(Error::from)?;

        {
            let mut table = write_txn.open_table(CONFIG_TABLE).map_err(Error::from)?;
            table
                .insert("quote_ttl", serde_json::to_string(&quote_ttl)?.as_str())
                .map_err(Error::from)?;
        }
        write_txn.commit().map_err(Error::from)?;

        Ok(())
    }
    async fn get_quote_ttl(&self) -> Result<QuoteTTL, database::Error> {
        let read_txn = self.db.begin_read().map_err(Error::from)?;
        let table = read_txn.open_table(CONFIG_TABLE).map_err(Error::from)?;

        if let Some(quote_ttl) = table.get("quote_ttl").map_err(Error::from)? {
            let quote_ttl = serde_json::from_str(quote_ttl.value())?;

            return Ok(quote_ttl);
        }

        Err(Error::UnknownQuoteTTL.into())
    }
}

#[cfg(test)]
mod tests {
    use cdk_common::secret::Secret;
    use cdk_common::{Amount, SecretKey};
    use tempfile::tempdir;

    use super::*;

    #[tokio::test]
    async fn test_remove_spent_proofs() {
        let tmp_dir = tempdir().unwrap();

        let db = MintRedbDatabase::new(&tmp_dir.path().join("mint.redb")).unwrap();
        // Create some test proofs
        let keyset_id = Id::from_str("00916bbf7ef91a36").unwrap();

        let proofs = vec![
            Proof {
                amount: Amount::from(100),
                keyset_id,
                secret: Secret::generate(),
                c: SecretKey::generate().public_key(),
                witness: None,
                dleq: None,
            },
            Proof {
                amount: Amount::from(200),
                keyset_id,
                secret: Secret::generate(),
                c: SecretKey::generate().public_key(),
                witness: None,
                dleq: None,
            },
        ];

        // Add proofs to database
        db.add_proofs(proofs.clone(), None).await.unwrap();

        // Mark one proof as spent
        db.update_proofs_states(&[proofs[0].y().unwrap()], State::Spent)
            .await
            .unwrap();

        db.update_proofs_states(&[proofs[1].y().unwrap()], State::Unspent)
            .await
            .unwrap();

        // Try to remove both proofs - should fail because one is spent
        let result = db
            .remove_proofs(&[proofs[0].y().unwrap(), proofs[1].y().unwrap()], None)
            .await;

        assert!(result.is_err());
        assert!(matches!(
            result.unwrap_err(),
            database::Error::AttemptRemoveSpentProof
        ));

        // Verify both proofs still exist
        let states = db
            .get_proofs_states(&[proofs[0].y().unwrap(), proofs[1].y().unwrap()])
            .await
            .unwrap();

        assert_eq!(states.len(), 2);
        assert_eq!(states[0], Some(State::Spent));
        assert_eq!(states[1], Some(State::Unspent));
    }

    #[tokio::test]
    async fn test_update_spent_proofs() {
        let tmp_dir = tempdir().unwrap();

        let db = MintRedbDatabase::new(&tmp_dir.path().join("mint.redb")).unwrap();
        // Create some test proofs
        let keyset_id = Id::from_str("00916bbf7ef91a36").unwrap();

        let proofs = vec![
            Proof {
                amount: Amount::from(100),
                keyset_id,
                secret: Secret::generate(),
                c: SecretKey::generate().public_key(),
                witness: None,
                dleq: None,
            },
            Proof {
                amount: Amount::from(200),
                keyset_id,
                secret: Secret::generate(),
                c: SecretKey::generate().public_key(),
                witness: None,
                dleq: None,
            },
        ];

        // Add proofs to database
        db.add_proofs(proofs.clone(), None).await.unwrap();

        // Mark one proof as spent
        db.update_proofs_states(&[proofs[0].y().unwrap()], State::Spent)
            .await
            .unwrap();

        db.update_proofs_states(&[proofs[1].y().unwrap()], State::Unspent)
            .await
            .unwrap();

        // Mark one proof as spent
        let result = db
            .update_proofs_states(
                &[proofs[0].y().unwrap(), proofs[1].y().unwrap()],
                State::Unspent,
            )
            .await;

        assert!(result.is_err());
        assert!(matches!(
            result.unwrap_err(),
            database::Error::AttemptUpdateSpentProof
        ));

        // Verify both proofs still exist
        let states = db
            .get_proofs_states(&[proofs[0].y().unwrap(), proofs[1].y().unwrap()])
            .await
            .unwrap();

        assert_eq!(states.len(), 2);
        assert_eq!(states[0], Some(State::Spent));
        assert_eq!(states[1], Some(State::Unspent));
    }
}