feat: remove rexie

README.md

@@ -18,7 +18,6 @@ The project is split up into several crates in the `crates/` directory:
     * [**cdk**](./crates/cdk/): Rust implementation of Cashu protocol.
     * [**cdk-sqlite**](./crates/cdk-sqlite/): SQLite Storage backend.
     * [**cdk-redb**](./crates/cdk-redb/): Redb Storage backend.
-    * [**cdk-rexie**](./crates/cdk-rexie/): Rexie Storage backend for browsers.
     * [**cdk-axum**](./crates/cdk-axum/): Axum webserver for mint.
     * [**cdk-cln**](./crates/cdk-cln/): CLN Lightning backend for mint.
     * [**cdk-lnd**](./crates/cdk-lnd/): Lnd Lightning backend for mint.

crates/cdk-rexie/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-name = "cdk-rexie"
-version.workspace = true
-edition.workspace = true
-authors = ["CDK Developers"]
-description = "Indexdb storage backend for CDK in the browser"
-license.workspace = true
-homepage = "https://github.com/cashubtc/cdk"
-repository = "https://github.com/cashubtc/cdk.git"
-rust-version.workspace = true # MSRV
-readme = "README.md"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-[features]
-default = ["wallet"]
-wallet = ["cdk/wallet"]
-
-[dependencies]
-rexie = "0.6.0"
-cdk.workspace = true
-async-trait.workspace = true
-tokio.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-thiserror.workspace = true
-serde-wasm-bindgen = "0.6.5"
-web-sys =  { version = "0.3.69", default-features = false, features = ["console"] }

crates/cdk-rexie/README.md

@@ -1,35 +0,0 @@
-# CDK Rexie
-
-[![crates.io](https://img.shields.io/crates/v/cdk-rexie.svg)](https://crates.io/crates/cdk-rexie)
-[![Documentation](https://docs.rs/cdk-rexie/badge.svg)](https://docs.rs/cdk-rexie)
-[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/cashubtc/cdk/blob/main/LICENSE)
-
-**ALPHA** This library is in early development, the API will change and should be used with caution.
-
-[Rexie](https://github.com/SaltyAom/rexie) (IndexedDB) storage backend implementation for the Cashu Development Kit (CDK). This provides browser-based storage for web applications.
-
-## Features
-
-This crate provides a Rexie-based storage implementation for browser environments:
-- Wallet storage
-- Transaction history
-- Proof tracking
-- IndexedDB persistence
-
-## Installation
-
-Add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-cdk-rexie = "*"
-```
-
-
-## WASM Support
-
-This crate is specifically designed for use in WebAssembly environments and requires the `wasm32-unknown-unknown` target.
-
-## License
-
-This project is licensed under the [MIT License](../../LICENSE).

crates/cdk-rexie/src/lib.rs

@@ -1,10 +0,0 @@
-//! Rexie Indexdb database
-
-#![warn(missing_docs)]
-#![warn(rustdoc::bare_urls)]
-
-#[cfg(all(feature = "wallet", target_arch = "wasm32"))]
-pub mod wallet;
-
-#[cfg(all(feature = "wallet", target_arch = "wasm32"))]
-pub use wallet::WalletRexieDatabase;

crates/cdk-rexie/src/wallet.rs

@@ -1,751 +0,0 @@
-//! Rexie Browser Database
-
-use std::collections::{HashMap, HashSet};
-use std::rc::Rc;
-use std::result::Result;
-
-use async_trait::async_trait;
-use cdk::cdk_database::{self, WalletDatabase};
-use cdk::mint_url::MintUrl;
-use cdk::nuts::{
-    CurrencyUnit, Id, KeySetInfo, Keys, MintInfo, PublicKey, SpendingConditions, State,
-};
-use cdk::types::ProofInfo;
-use cdk::util::unix_time;
-use cdk::wallet::{MeltQuote, MintQuote};
-use rexie::*;
-use thiserror::Error;
-use tokio::sync::Mutex;
-
-// Tables
-const MINTS: &str = "mints";
-const MINT_KEYSETS: &str = "keysets_by_mint";
-const KEYSETS: &str = "keysets";
-const MINT_KEYS: &str = "mint_keys";
-const MINT_QUOTES: &str = "mint_quotes";
-const MELT_QUOTES: &str = "melt_quotes";
-const PROOFS: &str = "proofs";
-const CONFIG: &str = "config";
-const KEYSET_COUNTER: &str = "keyset_counter";
-
-const DATABASE_VERSION: u32 = 4;
-
-/// Rexie Database Error
-#[derive(Debug, Error)]
-pub enum Error {
-    /// CDK Database Error
-    #[error(transparent)]
-    CDKDatabase(#[from] cdk::cdk_database::Error),
-    /// Rexie Error
-    #[error(transparent)]
-    Rexie(#[from] rexie::Error),
-    /// Serde Wasm Error
-    #[error(transparent)]
-    SerdeBindgen(#[from] serde_wasm_bindgen::Error),
-    /// NUT00 Error
-    #[error(transparent)]
-    NUT00(cdk::nuts::nut00::Error),
-    #[error("Not found")]
-    /// Not Found
-    NotFound,
-}
-impl From<Error> for cdk::cdk_database::Error {
-    fn from(e: Error) -> Self {
-        Self::Database(Box::new(e))
-    }
-}
-
-// These are okay because we never actually send across threads in the browser
-unsafe impl Send for Error {}
-unsafe impl Sync for Error {}
-
-/// Wallet Rexie Database
-#[derive(Debug, Clone)]
-pub struct WalletRexieDatabase {
-    db: Rc<Mutex<Rexie>>,
-}
-
-// These are okay because we never actually send across threads in the browser
-unsafe impl Send for WalletRexieDatabase {}
-unsafe impl Sync for WalletRexieDatabase {}
-
-impl WalletRexieDatabase {
-    /// Create new [`WalletRexieDatabase`]
-    pub async fn new() -> Result<Self, Error> {
-        let rexie = Rexie::builder("cdk")
-            .version(DATABASE_VERSION)
-            .add_object_store(
-                ObjectStore::new(PROOFS)
-                    .add_index(Index::new("y", "y").unique(true))
-                    .add_index(Index::new("mint_url", "mint_url"))
-                    .add_index(Index::new("state", "state"))
-                    .add_index(Index::new("unit", "unit")),
-            )
-            .add_object_store(
-                ObjectStore::new(MINTS).add_index(Index::new("mint_url", "mint_url").unique(true)),
-            )
-            .add_object_store(ObjectStore::new(MINT_KEYSETS))
-            .add_object_store(
-                ObjectStore::new(KEYSETS)
-                    .add_index(Index::new("keyset_id", "keyset_id").unique(true)),
-            )
-            .add_object_store(
-                ObjectStore::new(MINT_KEYS)
-                    .add_index(Index::new("keyset_id", "keyset_id").unique(true)),
-            )
-            .add_object_store(ObjectStore::new(MINT_QUOTES))
-            .add_object_store(ObjectStore::new(MELT_QUOTES))
-            .add_object_store(ObjectStore::new(CONFIG))
-            .add_object_store(ObjectStore::new(KEYSET_COUNTER))
-            // Build the database
-            .build()
-            .await
-            .unwrap();
-
-        Ok(Self {
-            db: Rc::new(Mutex::new(rexie)),
-        })
-    }
-
-    async fn set_proof_states(
-        &self,
-        ys: Vec<PublicKey>,
-        state: State,
-    ) -> Result<(), cdk_database::Error> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[PROOFS], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let proofs_store = transaction.store(PROOFS).map_err(Error::from)?;
-
-        for y in ys {
-            let y = serde_wasm_bindgen::to_value(&y).map_err(Error::from)?;
-
-            let mut proof: ProofInfo = proofs_store
-                .get(y.clone())
-                .await
-                .map_err(Error::from)?
-                .and_then(|p| serde_wasm_bindgen::from_value(p).ok())
-                .ok_or(Error::NotFound)?;
-
-            proof.state = state;
-
-            let proof = serde_wasm_bindgen::to_value(&proof).map_err(Error::from)?;
-
-            proofs_store
-                .put(&proof, Some(&y))
-                .await
-                .map_err(Error::from)?;
-        }
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(())
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl WalletDatabase for WalletRexieDatabase {
-    type Err = cdk::cdk_database::Error;
-
-    async fn add_mint(
-        &self,
-        mint_url: MintUrl,
-        mint_info: Option<MintInfo>,
-    ) -> Result<(), Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINTS], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let mints_store = transaction.store(MINTS).map_err(Error::from)?;
-
-        let mint_url = serde_wasm_bindgen::to_value(&mint_url).map_err(Error::from)?;
-        let mint_info = serde_wasm_bindgen::to_value(&mint_info).map_err(Error::from)?;
-
-        mints_store
-            .put(&mint_info, Some(&mint_url))
-            .await
-            .map_err(Error::from)?;
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(())
-    }
-
-    async fn remove_mint(&self, mint_url: MintUrl) -> Result<(), Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINTS], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let mints_store = transaction.store(MINTS).map_err(Error::from)?;
-
-        let mint_url = serde_wasm_bindgen::to_value(&mint_url).map_err(Error::from)?;
-
-        mints_store.delete(mint_url).await.map_err(Error::from)?;
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(())
-    }
-
-    async fn get_mint(&self, mint_url: MintUrl) -> Result<Option<MintInfo>, Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINTS], TransactionMode::ReadOnly)
-            .map_err(Error::from)?;
-
-        let mints_store = transaction.store(MINTS).map_err(Error::from)?;
-
-        let mint_url = serde_wasm_bindgen::to_value(&mint_url).map_err(Error::from)?;
-        let mint_info = mints_store
-            .get(mint_url)
-            .await
-            .map_err(Error::from)?
-            .and_then(|m| serde_wasm_bindgen::from_value(m).ok());
-
-        Ok(mint_info)
-    }
-
-    async fn get_mints(&self) -> Result<HashMap<MintUrl, Option<MintInfo>>, Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINTS], TransactionMode::ReadOnly)
-            .map_err(Error::from)?;
-
-        let mints_store = transaction.store(MINTS).map_err(Error::from)?;
-
-        let mints = mints_store
-            .scan(None, None, None, None)
-            .await
-            .map_err(Error::from)?;
-
-        let mints: HashMap<MintUrl, Option<MintInfo>> = mints
-            .into_iter()
-            .map(|(url, info)| {
-                (
-                    serde_wasm_bindgen::from_value(url).unwrap(),
-                    serde_wasm_bindgen::from_value(info).unwrap(),
-                )
-            })
-            .collect();
-
-        Ok(mints)
-    }
-
-    async fn update_mint_url(
-        &self,
-        old_mint_url: MintUrl,
-        new_mint_url: MintUrl,
-    ) -> Result<(), Self::Err> {
-        let proofs = self
-            .get_proofs(Some(old_mint_url), None, None, None)
-            .await
-            .map_err(Error::from)?;
-
-        let updated_proofs: Vec<ProofInfo> = proofs
-            .into_iter()
-            .map(|mut p| {
-                p.mint_url = new_mint_url.clone();
-                p
-            })
-            .collect();
-
-        if !updated_proofs.is_empty() {
-            self.update_proofs(updated_proofs, vec![]).await?;
-        }
-
-        // Update mint quotes
-        {
-            let quotes = self.get_mint_quotes().await?;
-
-            let unix_time = unix_time();
-
-            let quotes: Vec<MintQuote> = quotes
-                .into_iter()
-                .filter_map(|mut q| {
-                    if q.expiry < unix_time {
-                        q.mint_url = new_mint_url.clone();
-                        Some(q)
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-
-            for quote in quotes {
-                self.add_mint_quote(quote).await?;
-            }
-        }
-
-        Ok(())
-    }
-
-    async fn add_mint_keysets(
-        &self,
-        mint_url: MintUrl,
-        keysets: Vec<KeySetInfo>,
-    ) -> Result<(), Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINT_KEYSETS, KEYSETS], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let mint_keysets_store = transaction.store(MINT_KEYSETS).map_err(Error::from)?;
-        let keysets_store = transaction.store(KEYSETS).map_err(Error::from)?;
-
-        let mint_url = serde_wasm_bindgen::to_value(&mint_url).map_err(Error::from)?;
-
-        let mut mint_keysets = mint_keysets_store
-            .get(mint_url.clone())
-            .await
-            .map_err(Error::from)?
-            .and_then(|m| serde_wasm_bindgen::from_value(m).ok());
-
-        let new_keyset_ids: Vec<Id> = keysets.iter().map(|k| k.id).collect();
-
-        mint_keysets
-            .as_mut()
-            .unwrap_or(&mut HashSet::new())
-            .extend(new_keyset_ids);
-
-        let mint_keysets = serde_wasm_bindgen::to_value(&mint_keysets).map_err(Error::from)?;
-
-        mint_keysets_store
-            .put(&mint_keysets, Some(&mint_url))
-            .await
-            .map_err(Error::from)?;
-
-        for keyset in keysets {
-            let id = serde_wasm_bindgen::to_value(&keyset.id).map_err(Error::from)?;
-            let keyset = serde_wasm_bindgen::to_value(&keyset).map_err(Error::from)?;
-
-            keysets_store
-                .put(&keyset, Some(&id))
-                .await
-                .map_err(Error::from)?;
-        }
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(())
-    }
-
-    async fn get_mint_keysets(
-        &self,
-        mint_url: MintUrl,
-    ) -> Result<Option<Vec<KeySetInfo>>, Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINT_KEYSETS, KEYSETS], TransactionMode::ReadOnly)
-            .map_err(Error::from)?;
-
-        let mints_store = transaction.store(MINT_KEYSETS).map_err(Error::from)?;
-
-        let mint_url = serde_wasm_bindgen::to_value(&mint_url).map_err(Error::from)?;
-        let mint_keysets: Option<HashSet<Id>> = mints_store
-            .get(mint_url)
-            .await
-            .map_err(Error::from)?
-            .and_then(|m| serde_wasm_bindgen::from_value(m).ok());
-
-        let keysets_store = transaction.store(KEYSETS).map_err(Error::from)?;
-
-        let keysets = match mint_keysets {
-            Some(mint_keysets) => {
-                let mut keysets = vec![];
-
-                for mint_keyset in mint_keysets {
-                    let id = serde_wasm_bindgen::to_value(&mint_keyset).map_err(Error::from)?;
-
-                    let keyset = keysets_store
-                        .get(id)
-                        .await
-                        .map_err(Error::from)?
-                        .and_then(|k| serde_wasm_bindgen::from_value(k).ok());
-
-                    keysets.push(keyset);
-                }
-
-                let keysets = keysets.iter().flatten().cloned().collect();
-
-                Some(keysets)
-            }
-            None => None,
-        };
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(keysets)
-    }
-
-    async fn get_keyset_by_id(&self, keyset_id: &Id) -> Result<Option<KeySetInfo>, Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[KEYSETS], TransactionMode::ReadOnly)
-            .map_err(Error::from)?;
-        let keysets_store = transaction.store(KEYSETS).map_err(Error::from)?;
-
-        let keyset_id = serde_wasm_bindgen::to_value(keyset_id).map_err(Error::from)?;
-
-        let keyset = keysets_store
-            .get(keyset_id)
-            .await
-            .map_err(Error::from)?
-            .and_then(|k| serde_wasm_bindgen::from_value(k).ok());
-
-        Ok(keyset)
-    }
-
-    async fn add_mint_quote(&self, quote: MintQuote) -> Result<(), Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINT_QUOTES], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let quotes_store = transaction.store(MINT_QUOTES).map_err(Error::from)?;
-
-        let quote_id = serde_wasm_bindgen::to_value(&quote.id).map_err(Error::from)?;
-        let quote = serde_wasm_bindgen::to_value(&quote).map_err(Error::from)?;
-
-        quotes_store
-            .put(&quote, Some(&quote_id))
-            .await
-            .map_err(Error::from)?;
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(())
-    }
-
-    async fn get_mint_quote(&self, quote_id: &str) -> Result<Option<MintQuote>, Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINT_QUOTES], TransactionMode::ReadOnly)
-            .map_err(Error::from)?;
-
-        let quotes_store = transaction.store(MINT_QUOTES).map_err(Error::from)?;
-
-        let quote_id = serde_wasm_bindgen::to_value(&quote_id).map_err(Error::from)?;
-        let quote = quotes_store
-            .get(quote_id)
-            .await
-            .map_err(Error::from)?
-            .and_then(|q| serde_wasm_bindgen::from_value(q).ok());
-
-        Ok(quote)
-    }
-
-    async fn get_mint_quotes(&self) -> Result<Vec<MintQuote>, Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINT_QUOTES], TransactionMode::ReadOnly)
-            .map_err(Error::from)?;
-
-        let quotes_store = transaction.store(MINT_QUOTES).map_err(Error::from)?;
-
-        let quotes = quotes_store
-            .scan(None, None, None, None)
-            .await
-            .map_err(Error::from)?;
-
-        Ok(quotes
-            .into_iter()
-            .map(|(_id, q)| serde_wasm_bindgen::from_value(q))
-            .collect::<Result<Vec<MintQuote>, serde_wasm_bindgen::Error>>()
-            .map_err(<serde_wasm_bindgen::Error as Into<Error>>::into)?)
-    }
-
-    async fn remove_mint_quote(&self, quote_id: &str) -> Result<(), Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINT_QUOTES], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let quotes_store = transaction.store(MINT_QUOTES).map_err(Error::from)?;
-
-        let quote_id = serde_wasm_bindgen::to_value(&quote_id).map_err(Error::from)?;
-
-        quotes_store.delete(quote_id).await.map_err(Error::from)?;
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(())
-    }
-
-    async fn add_melt_quote(&self, quote: MeltQuote) -> Result<(), Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MELT_QUOTES], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let quotes_store = transaction.store(MELT_QUOTES).map_err(Error::from)?;
-
-        let quote_id = serde_wasm_bindgen::to_value(&quote.id).map_err(Error::from)?;
-        let quote = serde_wasm_bindgen::to_value(&quote).map_err(Error::from)?;
-
-        quotes_store
-            .put(&quote, Some(&quote_id))
-            .await
-            .map_err(Error::from)?;
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(())
-    }
-
-    async fn get_melt_quote(&self, quote_id: &str) -> Result<Option<MeltQuote>, Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MELT_QUOTES], TransactionMode::ReadOnly)
-            .map_err(Error::from)?;
-
-        let quotes_store = transaction.store(MELT_QUOTES).map_err(Error::from)?;
-
-        let quote_id = serde_wasm_bindgen::to_value(&quote_id).map_err(Error::from)?;
-        let quote = quotes_store
-            .get(quote_id)
-            .await
-            .map_err(Error::from)?
-            .and_then(|q| serde_wasm_bindgen::from_value(q).ok());
-
-        Ok(quote)
-    }
-
-    async fn remove_melt_quote(&self, quote_id: &str) -> Result<(), Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MELT_QUOTES], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let quotes_store = transaction.store(MELT_QUOTES).map_err(Error::from)?;
-
-        let quote_id = serde_wasm_bindgen::to_value(&quote_id).map_err(Error::from)?;
-
-        quotes_store.delete(quote_id).await.map_err(Error::from)?;
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(())
-    }
-
-    async fn add_keys(&self, keyset: KeySet) -> Result<(), Self::Err> {
-        // Verify ID by recomputing id
-        keyset.verify_id()?;
-
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINT_KEYS], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let keys_store = transaction.store(MINT_KEYS).map_err(Error::from)?;
-
-        let keyset_id = serde_wasm_bindgen::to_value(&keyset.id).map_err(Error::from)?;
-        let keys = serde_wasm_bindgen::to_value(&keys).map_err(Error::from)?;
-
-        keys_store
-            .put(&keys, Some(&keyset_id))
-            .await
-            .map_err(Error::from)?;
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(())
-    }
-
-    async fn get_keys(&self, id: &Id) -> Result<Option<Keys>, Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINT_KEYS], TransactionMode::ReadOnly)
-            .map_err(Error::from)?;
-
-        let keys_store = transaction.store(MINT_KEYS).map_err(Error::from)?;
-
-        let keyset_id = serde_wasm_bindgen::to_value(id).map_err(Error::from)?;
-        let keys = keys_store
-            .get(keyset_id)
-            .await
-            .map_err(Error::from)?
-            .and_then(|k| serde_wasm_bindgen::from_value(k).ok());
-
-        Ok(keys)
-    }
-
-    async fn remove_keys(&self, id: &Id) -> Result<(), Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[MINT_KEYS], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let keys_store = transaction.store(MINT_KEYS).map_err(Error::from)?;
-
-        let keyset_id = serde_wasm_bindgen::to_value(id).map_err(Error::from)?;
-        keys_store.delete(keyset_id).await.map_err(Error::from)?;
-
-        Ok(())
-    }
-
-    async fn update_proofs(
-        &self,
-        added: Vec<ProofInfo>,
-        removed_ys: Vec<PublicKey>,
-    ) -> Result<(), Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[PROOFS], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let proofs_store = transaction.store(PROOFS).map_err(Error::from)?;
-
-        for proof in added {
-            let y = serde_wasm_bindgen::to_value(&proof.y).map_err(Error::from)?;
-            let proof = serde_wasm_bindgen::to_value(&proof).map_err(Error::from)?;
-
-            proofs_store
-                .put(&proof, Some(&y))
-                .await
-                .map_err(Error::from)?;
-        }
-
-        for y in removed_ys {
-            let y = serde_wasm_bindgen::to_value(&y).map_err(Error::from)?;
-
-            proofs_store.delete(y).await.map_err(Error::from)?;
-        }
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(())
-    }
-
-    async fn set_pending_proofs(&self, ys: Vec<PublicKey>) -> Result<(), Self::Err> {
-        self.set_proof_states(ys, State::Pending).await
-    }
-
-    async fn reserve_proofs(&self, ys: Vec<PublicKey>) -> Result<(), Self::Err> {
-        self.set_proof_states(ys, State::Reserved).await
-    }
-
-    async fn set_unspent_proofs(&self, ys: Vec<PublicKey>) -> Result<(), Self::Err> {
-        self.set_proof_states(ys, State::Unspent).await
-    }
-
-    async fn get_proofs(
-        &self,
-        mint_url: Option<MintUrl>,
-        unit: Option<CurrencyUnit>,
-        state: Option<Vec<State>>,
-        spending_conditions: Option<Vec<SpendingConditions>>,
-    ) -> Result<Vec<ProofInfo>, Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[PROOFS], TransactionMode::ReadOnly)
-            .map_err(Error::from)?;
-
-        let proofs_store = transaction.store(PROOFS).map_err(Error::from)?;
-
-        let proofs = proofs_store
-            .scan(None, None, None, None)
-            .await
-            .map_err(Error::from)?;
-
-        let proofs: Vec<ProofInfo> = proofs
-            .into_iter()
-            .filter_map(|(_k, v)| {
-                let mut proof = None;
-
-                if let Ok(proof_info) = serde_wasm_bindgen::from_value::<ProofInfo>(v) {
-                    proof = match proof_info.matches_conditions(
-                        &mint_url,
-                        &unit,
-                        &state,
-                        &spending_conditions,
-                    ) {
-                        true => Some(proof_info),
-                        false => None,
-                    };
-                }
-
-                proof
-            })
-            .collect();
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(proofs)
-    }
-
-    async fn increment_keyset_counter(&self, keyset_id: &Id, count: u32) -> Result<(), Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[KEYSET_COUNTER], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let counter_store = transaction.store(KEYSET_COUNTER).map_err(Error::from)?;
-
-        let keyset_id = serde_wasm_bindgen::to_value(keyset_id).map_err(Error::from)?;
-
-        let current_count: Option<u32> = counter_store
-            .get(keyset_id.clone())
-            .await
-            .map_err(Error::from)?
-            .and_then(|c| serde_wasm_bindgen::from_value(c).ok());
-
-        let new_count = current_count.unwrap_or_default() + count;
-
-        let new_count = serde_wasm_bindgen::to_value(&new_count).map_err(Error::from)?;
-
-        counter_store
-            .put(&new_count, Some(&keyset_id))
-            .await
-            .map_err(Error::from)?;
-
-        transaction.done().await.map_err(Error::from)?;
-
-        Ok(())
-    }
-
-    async fn get_keyset_counter(&self, keyset_id: &Id) -> Result<Option<u32>, Self::Err> {
-        let rexie = self.db.lock().await;
-
-        let transaction = rexie
-            .transaction(&[KEYSET_COUNTER], TransactionMode::ReadWrite)
-            .map_err(Error::from)?;
-
-        let counter_store = transaction.store(KEYSET_COUNTER).map_err(Error::from)?;
-
-        let keyset_id = serde_wasm_bindgen::to_value(keyset_id).map_err(Error::from)?;
-
-        let current_count = counter_store
-            .get(keyset_id)
-            .await
-            .map_err(Error::from)?
-            .and_then(|c| serde_wasm_bindgen::from_value(c).ok());
-
-        Ok(current_count)
-    }
-}

justfile

@@ -192,7 +192,6 @@ release m="":
     "-p cdk-redb"
     "-p cdk-signatory"
     "-p cdk"
-    "-p cdk-rexie"
     "-p cdk-axum"
     "-p cdk-mint-rpc"
     "-p cdk-cln"
@@ -221,7 +220,6 @@ check-docs:
     "-p cdk-redb"
     "-p cdk-sqlite"
     "-p cdk-axum"
-    "-p cdk-rexie"
     "-p cdk-cln"
     "-p cdk-lnd"
     "-p cdk-lnbits"
@@ -249,7 +247,6 @@ docs-strict:
     "-p cdk-redb"
     "-p cdk-sqlite"
     "-p cdk-axum"
-    "-p cdk-rexie"
     "-p cdk-cln"
     "-p cdk-lnd"
     "-p cdk-lnbits"

misc/justfile.custom.just

@@ -72,7 +72,6 @@ release m="":
     "-p cdk"
     "-p cdk-redb"
     "-p cdk-sqlite"
-    "-p cdk-rexie"
     "-p cdk-axum"
     "-p cdk-mint-rpc"
     "-p cdk-cln"
@@ -100,7 +99,6 @@ check-docs:
     "-p cdk-redb"
     "-p cdk-sqlite"
     "-p cdk-axum"
-    "-p cdk-rexie"
     "-p cdk-cln"
     "-p cdk-lnd"
     "-p cdk-lnbits"