feat: get proofs for quote id

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

@@ -543,6 +543,26 @@ impl MintDatabase for MintRedbDatabase {
         Ok(proofs)
     }
 
+    async fn get_proof_ys_by_quote_id(&self, quote_id: &str) -> 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).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

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

@@ -814,6 +814,52 @@ WHERE y=?;
         Ok(proofs)
     }
 
+    async fn get_proof_ys_by_quote_id(&self, quote_id: &str) -> Result<Vec<PublicKey>, Self::Err> {
+        let mut transaction = self.pool.begin().await.map_err(Error::from)?;
+
+        let rec = sqlx::query(
+            r#"
+SELECT *
+FROM proof
+WHERE quote_id=?;
+        "#,
+        )
+        .bind(quote_id)
+        .fetch_all(&mut transaction)
+        .await;
+
+        let ys = match rec {
+            Ok(rec) => {
+                transaction.commit().await.map_err(Error::from)?;
+
+                let proofs = rec
+                    .into_iter()
+                    .map(sqlite_row_to_proof)
+                    .collect::<Result<Vec<Proof>, _>>()?;
+
+                proofs
+                    .iter()
+                    .map(|p| p.y())
+                    .collect::<Result<Vec<PublicKey>, _>>()?
+            }
+            Err(err) => match err {
+                sqlx::Error::RowNotFound => {
+                    transaction.commit().await.map_err(Error::from)?;
+
+                    vec![]
+                }
+                _ => {
+                    if let Err(err) = transaction.rollback().await {
+                        tracing::error!("Could not rollback sql transaction: {}", err);
+                    }
+                    return Err(Error::SQLX(err).into());
+                }
+            },
+        };
+
+        Ok(ys)
+    }
+
     async fn get_proofs_states(&self, ys: &[PublicKey]) -> Result<Vec<Option<State>>, Self::Err> {
         let mut transaction = self.pool.begin().await.map_err(Error::from)?;
 

crates/cdk/src/cdk_database/mint_memory.rs

@@ -262,6 +262,15 @@ impl MintDatabase for MintMemoryDatabase {
         Ok(proofs)
     }
 
+    async fn get_proof_ys_by_quote_id(&self, quote_id: &str) -> Result<Vec<PublicKey>, Self::Err> {
+        let quote_proofs = &__self.quote_proofs.lock().await;
+
+        match quote_proofs.get(quote_id) {
+            Some(ys) => Ok(ys.clone()),
+            None => Ok(vec![]),
+        }
+    }
+
     async fn update_proofs_states(
         &self,
         ys: &[PublicKey],

crates/cdk/src/cdk_database/mod.rs

@@ -231,6 +231,8 @@ pub trait MintDatabase {
     async fn add_proofs(&self, proof: Proofs, quote_id: Option<String>) -> Result<(), Self::Err>;
     /// Get [`Proofs`] by ys
     async fn get_proofs_by_ys(&self, ys: &[PublicKey]) -> Result<Vec<Option<Proof>>, Self::Err>;
+    /// Get ys by quote id
+    async fn get_proof_ys_by_quote_id(&self, quote_id: &str) -> Result<Vec<PublicKey>, Self::Err>;
     /// Get [`Proofs`] state
     async fn get_proofs_states(&self, ys: &[PublicKey]) -> Result<Vec<Option<State>>, Self::Err>;
     /// Get [`Proofs`] state