From b4c68c777ac8b6d66d80c9d6ceeee8024a6ca7bb Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Fri, 20 Jun 2025 10:50:47 +0200
Subject: [PATCH 01/18] Register spent transaction with txid or blockid raw
 bytes not hex string

---
 src/client/structs.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/client/structs.rs b/src/client/structs.rs
index dccc587..d3718cb 100644
--- a/src/client/structs.rs
+++ b/src/client/structs.rs
@@ -12,8 +12,8 @@ use bitcoin::{
 use serde::{Deserialize, Serialize};
 use silentpayments::{receiving::Label, SilentPaymentAddress};
 
-type SpendingTxId = String;
-type MinedInBlock = String;
+type SpendingTxId = [u8; 32];
+type MinedInBlock = [u8; 32];
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub enum OutputSpendStatus {

From 1c4a7e294882756864b54b408a615f9f6c6ae195 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Sat, 21 Jun 2025 17:11:10 +0200
Subject: [PATCH 02/18] Reexport futures

---
 src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/lib.rs b/src/lib.rs
index c055981..2e27d2b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,6 +7,7 @@ mod updater;
 pub use bdk_coin_select::FeeRate;
 pub use bitcoin;
 pub use silentpayments;
+pub use futures;
 
 pub use backend::*;
 pub use client::*;

From dcf97ac2aabe1e8d9078888040c22f0a7f72aee2 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Mon, 18 Aug 2025 11:36:19 +0200
Subject: [PATCH 03/18] Abstract SpScanner into a trait

---
 src/scanner/mod.rs     | 336 +++++++++++++++++++++++++++++++++++-
 src/scanner/scanner.rs | 380 -----------------------------------------
 2 files changed, 334 insertions(+), 382 deletions(-)
 delete mode 100644 src/scanner/scanner.rs

diff --git a/src/scanner/mod.rs b/src/scanner/mod.rs
index 2d6bea2..2ddc51d 100644
--- a/src/scanner/mod.rs
+++ b/src/scanner/mod.rs
@@ -1,3 +1,335 @@
-mod scanner;
+use std::collections::{HashMap, HashSet};
 
-pub use scanner::SpScanner;
+use anyhow::{Error, Result};
+use bitcoin::{
+    absolute::Height, bip158::BlockFilter, hashes::{sha256, Hash}, 
+    Amount, BlockHash, OutPoint, Txid, XOnlyPublicKey
+};
+use futures::Stream;
+use silentpayments::receiving::Label;
+
+use crate::{
+    backend::{BlockData, FilterData, UtxoData},
+    client::{OwnedOutput, SpClient},
+    updater::Updater,
+};
+
+use crate::backend::ChainBackend;
+
+/// Trait for scanning silent payment blocks
+/// 
+/// This trait abstracts the core scanning functionality, allowing consumers
+/// to implement it with their own constraints and requirements.
+#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
+pub trait SpScanner {
+    /// Scan a range of blocks for silent payment outputs and inputs
+    /// 
+    /// # Arguments
+    /// * `start` - Starting block height (inclusive)
+    /// * `end` - Ending block height (inclusive)
+    /// * `dust_limit` - Minimum amount to consider (dust outputs are ignored)
+    /// * `with_cutthrough` - Whether to use cutthrough optimization
+    async fn scan_blocks(
+        &mut self,
+        start: Height,
+        end: Height,
+        dust_limit: Amount,
+        with_cutthrough: bool,
+    ) -> Result<()>;
+
+    /// Process a single block's data
+    /// 
+    /// # Arguments
+    /// * `blockdata` - Block data containing tweaks and filters
+    /// 
+    /// # Returns
+    /// * `(found_outputs, found_inputs)` - Tuple of found outputs and spent inputs
+    async fn process_block(
+        &mut self,
+        blockdata: BlockData,
+    ) -> Result<(HashMap<OutPoint, OwnedOutput>, HashSet<OutPoint>)>;
+
+    /// Process block outputs to find owned silent payment outputs
+    /// 
+    /// # Arguments
+    /// * `blkheight` - Block height
+    /// * `tweaks` - List of tweak public keys
+    /// * `new_utxo_filter` - Filter data for new UTXOs
+    /// 
+    /// # Returns
+    /// * Map of outpoints to owned outputs
+    async fn process_block_outputs(
+        &self,
+        blkheight: Height,
+        tweaks: Vec<bitcoin::secp256k1::PublicKey>,
+        new_utxo_filter: FilterData,
+    ) -> Result<HashMap<OutPoint, OwnedOutput>>;
+
+    /// Process block inputs to find spent outputs
+    /// 
+    /// # Arguments
+    /// * `blkheight` - Block height
+    /// * `spent_filter` - Filter data for spent outputs
+    /// 
+    /// # Returns
+    /// * Set of spent outpoints
+    async fn process_block_inputs(
+        &self,
+        blkheight: Height,
+        spent_filter: FilterData,
+    ) -> Result<HashSet<OutPoint>>;
+
+    /// Get the block data stream for a range of blocks
+    /// 
+    /// # Arguments
+    /// * `range` - Range of block heights
+    /// * `dust_limit` - Minimum amount to consider
+    /// * `with_cutthrough` - Whether to use cutthrough optimization
+    /// 
+    /// # Returns
+    /// * Stream of block data results
+    fn get_block_data_stream(
+        &self,
+        range: std::ops::RangeInclusive<u32>,
+        dust_limit: Amount,
+        with_cutthrough: bool,
+    ) -> std::pin::Pin<Box<dyn Stream<Item = Result<BlockData>> + Send>>;
+
+    /// Check if scanning should be interrupted
+    /// 
+    /// # Returns
+    /// * `true` if scanning should stop, `false` otherwise
+    fn should_interrupt(&self) -> bool;
+
+    /// Save current state to persistent storage
+    fn save_state(&mut self) -> Result<()>;
+
+    /// Record found outputs for a block
+    /// 
+    /// # Arguments
+    /// * `height` - Block height
+    /// * `block_hash` - Block hash
+    /// * `outputs` - Found outputs
+    fn record_outputs(
+        &mut self,
+        height: Height,
+        block_hash: BlockHash,
+        outputs: HashMap<OutPoint, OwnedOutput>,
+    ) -> Result<()>;
+
+    /// Record spent inputs for a block
+    /// 
+    /// # Arguments
+    /// * `height` - Block height
+    /// * `block_hash` - Block hash
+    /// * `inputs` - Spent inputs
+    fn record_inputs(
+        &mut self,
+        height: Height,
+        block_hash: BlockHash,
+        inputs: HashSet<OutPoint>,
+    ) -> Result<()>;
+
+    /// Record scan progress
+    /// 
+    /// # Arguments
+    /// * `start` - Start height
+    /// * `current` - Current height
+    /// * `end` - End height
+    fn record_progress(&mut self, start: Height, current: Height, end: Height) -> Result<()>;
+
+    /// Get the silent payment client
+    fn client(&self) -> &SpClient;
+
+    /// Get the chain backend
+    fn backend(&self) -> &dyn ChainBackend;
+
+    /// Get the updater
+    fn updater(&mut self) -> &mut dyn Updater;
+
+    // Helper methods with default implementations
+
+    /// Process multiple blocks from a stream
+    /// 
+    /// This is a default implementation that can be overridden if needed
+    async fn process_blocks(
+        &mut self,
+        start: Height,
+        end: Height,
+        block_data_stream: impl Stream<Item = Result<BlockData>> + Unpin + Send,
+    ) -> Result<()> {
+        use futures::StreamExt;
+        use std::time::{Duration, Instant};
+
+        let mut update_time = Instant::now();
+        let mut stream = block_data_stream;
+
+        while let Some(blockdata) = stream.next().await {
+            let blockdata = blockdata?;
+            let blkheight = blockdata.blkheight;
+            let blkhash = blockdata.blkhash;
+
+            // stop scanning and return if interrupted
+            if self.should_interrupt() {
+                self.save_state()?;
+                return Ok(());
+            }
+
+            let mut save_to_storage = false;
+
+            // always save on last block or after 30 seconds since last save
+            if blkheight == end || update_time.elapsed() > Duration::from_secs(30) {
+                save_to_storage = true;
+            }
+
+            let (found_outputs, found_inputs) = self.process_block(blockdata).await?;
+
+            if !found_outputs.is_empty() {
+                save_to_storage = true;
+                self.record_outputs(blkheight, blkhash, found_outputs)?;
+            }
+
+            if !found_inputs.is_empty() {
+                save_to_storage = true;
+                self.record_inputs(blkheight, blkhash, found_inputs)?;
+            }
+
+            // tell the updater we scanned this block
+            self.record_progress(start, blkheight, end)?;
+
+            if save_to_storage {
+                self.save_state()?;
+                update_time = Instant::now();
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Scan UTXOs for a given block and secrets map
+    /// 
+    /// This is a default implementation that can be overridden if needed
+    async fn scan_utxos(
+        &self,
+        blkheight: Height,
+        secrets_map: HashMap<[u8; 34], bitcoin::secp256k1::PublicKey>,
+    ) -> Result<Vec<(Option<Label>, UtxoData, bitcoin::secp256k1::Scalar)>> {
+        let utxos = self.backend().utxos(blkheight).await?;
+
+        let mut res: Vec<(Option<Label>, UtxoData, bitcoin::secp256k1::Scalar)> = vec![];
+
+        // group utxos by the txid
+        let mut txmap: HashMap<Txid, Vec<UtxoData>> = HashMap::new();
+        for utxo in utxos {
+            txmap.entry(utxo.txid).or_default().push(utxo);
+        }
+
+        for utxos in txmap.into_values() {
+            // check if we know the secret to any of the spks
+            let mut secret = None;
+            for utxo in utxos.iter() {
+                let spk = utxo.scriptpubkey.as_bytes();
+                if let Some(s) = secrets_map.get(spk) {
+                    secret = Some(s);
+                    break;
+                }
+            }
+
+            // skip this tx if no secret is found
+            let secret = match secret {
+                Some(secret) => secret,
+                None => continue,
+            };
+
+            let output_keys: Result<Vec<XOnlyPublicKey>> = utxos
+                .iter()
+                .filter_map(|x| {
+                    if x.scriptpubkey.is_p2tr() {
+                        Some(
+                            XOnlyPublicKey::from_slice(&x.scriptpubkey.as_bytes()[2..])
+                                .map_err(Error::new),
+                        )
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            let ours = self
+                .client()
+                .sp_receiver
+                .scan_transaction(secret, output_keys?)?;
+
+            for utxo in utxos {
+                if !utxo.scriptpubkey.is_p2tr() || utxo.spent {
+                    continue;
+                }
+
+                match XOnlyPublicKey::from_slice(&utxo.scriptpubkey.as_bytes()[2..]) {
+                    Ok(xonly) => {
+                        for (label, map) in ours.iter() {
+                            if let Some(scalar) = map.get(&xonly) {
+                                res.push((label.clone(), utxo, *scalar));
+                                break;
+                            }
+                        }
+                    }
+                    Err(_) => todo!(),
+                }
+            }
+        }
+
+        Ok(res)
+    }
+
+    /// Check if block contains relevant output transactions
+    /// 
+    /// This is a default implementation that can be overridden if needed
+    fn check_block_outputs(
+        created_utxo_filter: BlockFilter,
+        blkhash: BlockHash,
+        candidate_spks: Vec<&[u8; 34]>,
+    ) -> Result<bool> {
+        // check output scripts
+        let output_keys: Vec<_> = candidate_spks
+            .into_iter()
+            .map(|spk| spk[2..].as_ref())
+            .collect();
+
+        // note: match will always return true for an empty query!
+        if !output_keys.is_empty() {
+            Ok(created_utxo_filter.match_any(&blkhash, &mut output_keys.into_iter())?)
+        } else {
+            Ok(false)
+        }
+    }
+
+    /// Get input hashes for owned outpoints
+    /// 
+    /// This is a default implementation that can be overridden if needed
+    fn get_input_hashes(&self, blkhash: BlockHash) -> Result<HashMap<[u8; 8], OutPoint>> {
+        let mut map: HashMap<[u8; 8], OutPoint> = HashMap::new();
+
+        // This method needs access to owned_outpoints, which should be provided by the implementor
+        // For now, we'll return an empty map - implementors should override this method
+        Ok(map)
+    }
+
+    /// Check if block contains relevant input transactions
+    /// 
+    /// This is a default implementation that can be overridden if needed
+    fn check_block_inputs(
+        &self,
+        spent_filter: BlockFilter,
+        blkhash: BlockHash,
+        input_hashes: Vec<[u8; 8]>,
+    ) -> Result<bool> {
+        // note: match will always return true for an empty query!
+        if !input_hashes.is_empty() {
+            Ok(spent_filter.match_any(&blkhash, &mut input_hashes.into_iter())?)
+        } else {
+            Ok(false)
+        }
+    }
+}
diff --git a/src/scanner/scanner.rs b/src/scanner/scanner.rs
deleted file mode 100644
index 5ecc765..0000000
--- a/src/scanner/scanner.rs
+++ /dev/null
@@ -1,380 +0,0 @@
-use std::{
-    collections::{HashMap, HashSet},
-    sync::atomic::AtomicBool,
-    time::{Duration, Instant},
-};
-
-use anyhow::{bail, Error, Result};
-use bitcoin::{
-    absolute::Height,
-    bip158::BlockFilter,
-    hashes::{sha256, Hash},
-    secp256k1::{PublicKey, Scalar},
-    Amount, BlockHash, OutPoint, Txid, XOnlyPublicKey,
-};
-use futures::{pin_mut, Stream, StreamExt};
-use log::info;
-use silentpayments::receiving::Label;
-
-use crate::{
-    backend::{BlockData, ChainBackend, FilterData, UtxoData},
-    client::{OutputSpendStatus, OwnedOutput, SpClient},
-    updater::Updater,
-};
-
-pub struct SpScanner<'a> {
-    updater: Box<dyn Updater + Sync + Send>,
-    backend: Box<dyn ChainBackend + Sync + Send>,
-    client: SpClient,
-    keep_scanning: &'a AtomicBool,      // used to interrupt scanning
-    owned_outpoints: HashSet<OutPoint>, // used to scan block inputs
-}
-
-impl<'a> SpScanner<'a> {
-    pub fn new(
-        client: SpClient,
-        updater: Box<dyn Updater + Sync + Send>,
-        backend: Box<dyn ChainBackend + Sync + Send>,
-        owned_outpoints: HashSet<OutPoint>,
-        keep_scanning: &'a AtomicBool,
-    ) -> Self {
-        Self {
-            client,
-            updater,
-            backend,
-            owned_outpoints,
-            keep_scanning,
-        }
-    }
-
-    pub async fn scan_blocks(
-        &mut self,
-        start: Height,
-        end: Height,
-        dust_limit: Amount,
-        with_cutthrough: bool,
-    ) -> Result<()> {
-        if start > end {
-            bail!("bigger start than end: {} > {}", start, end);
-        }
-
-        info!("start: {} end: {}", start, end);
-        let start_time: Instant = Instant::now();
-
-        // get block data stream
-        let range = start.to_consensus_u32()..=end.to_consensus_u32();
-        let block_data_stream =
-            self.backend
-                .get_block_data_for_range(range, dust_limit, with_cutthrough);
-
-        // process blocks using block data stream
-        self.process_blocks(start, end, block_data_stream).await?;
-
-        // time elapsed for the scan
-        info!(
-            "Blindbit scan complete in {} seconds",
-            start_time.elapsed().as_secs()
-        );
-
-        Ok(())
-    }
-
-    async fn process_blocks(
-        &mut self,
-        start: Height,
-        end: Height,
-        block_data_stream: impl Stream<Item = Result<BlockData>>,
-    ) -> Result<()> {
-        pin_mut!(block_data_stream);
-
-        let mut update_time: Instant = Instant::now();
-
-        while let Some(blockdata) = block_data_stream.next().await {
-            let blockdata = blockdata?;
-            let blkheight = blockdata.blkheight;
-            let blkhash = blockdata.blkhash;
-
-            // stop scanning and return if interrupted
-            if self.interrupt_requested() {
-                self.updater.save_to_persistent_storage()?;
-                return Ok(());
-            }
-
-            let mut save_to_storage = false;
-
-            // always save on last block or after 30 seconds since last save
-            if blkheight == end || update_time.elapsed() > Duration::from_secs(30) {
-                save_to_storage = true;
-            }
-
-            let (found_outputs, found_inputs) = self.process_block(blockdata).await?;
-
-            if !found_outputs.is_empty() {
-                save_to_storage = true;
-                self.updater
-                    .record_block_outputs(blkheight, blkhash, found_outputs)?;
-            }
-
-            if !found_inputs.is_empty() {
-                save_to_storage = true;
-                self.updater
-                    .record_block_inputs(blkheight, blkhash, found_inputs)?;
-            }
-
-            // tell the updater we scanned this block
-            self.updater.record_scan_progress(start, blkheight, end)?;
-
-            if save_to_storage {
-                self.updater.save_to_persistent_storage()?;
-                update_time = Instant::now();
-            }
-        }
-
-        Ok(())
-    }
-
-    async fn process_block(
-        &mut self,
-        blockdata: BlockData,
-    ) -> Result<(HashMap<OutPoint, OwnedOutput>, HashSet<OutPoint>)> {
-        let BlockData {
-            blkheight,
-            tweaks,
-            new_utxo_filter,
-            spent_filter,
-            ..
-        } = blockdata;
-
-        let outs = self
-            .process_block_outputs(blkheight, tweaks, new_utxo_filter)
-            .await?;
-
-        // after processing outputs, we add the found outputs to our list
-        self.owned_outpoints.extend(outs.keys());
-
-        let ins = self.process_block_inputs(blkheight, spent_filter).await?;
-
-        // after processing inputs, we remove the found inputs
-        self.owned_outpoints.retain(|item| !ins.contains(item));
-
-        Ok((outs, ins))
-    }
-
-    async fn process_block_outputs(
-        &self,
-        blkheight: Height,
-        tweaks: Vec<PublicKey>,
-        new_utxo_filter: FilterData,
-    ) -> Result<HashMap<OutPoint, OwnedOutput>> {
-        let mut res = HashMap::new();
-
-        if !tweaks.is_empty() {
-            let secrets_map = self.client.get_script_to_secret_map(tweaks)?;
-
-            //last_scan = last_scan.max(n as u32);
-            let candidate_spks: Vec<&[u8; 34]> = secrets_map.keys().collect();
-
-            //get block gcs & check match
-            let blkfilter = BlockFilter::new(&new_utxo_filter.data);
-            let blkhash = new_utxo_filter.block_hash;
-
-            let matched_outputs = Self::check_block_outputs(blkfilter, blkhash, candidate_spks)?;
-
-            //if match: fetch and scan utxos
-            if matched_outputs {
-                info!("matched outputs on: {}", blkheight);
-                let found = self.scan_utxos(blkheight, secrets_map).await?;
-
-                if !found.is_empty() {
-                    for (label, utxo, tweak) in found {
-                        let outpoint = OutPoint {
-                            txid: utxo.txid,
-                            vout: utxo.vout,
-                        };
-
-                        let out = OwnedOutput {
-                            blockheight: blkheight,
-                            tweak: tweak.to_be_bytes(),
-                            amount: utxo.value,
-                            script: utxo.scriptpubkey,
-                            label,
-                            spend_status: OutputSpendStatus::Unspent,
-                        };
-
-                        res.insert(outpoint, out);
-                    }
-                }
-            }
-        }
-        Ok(res)
-    }
-
-    async fn process_block_inputs(
-        &self,
-        blkheight: Height,
-        spent_filter: FilterData,
-    ) -> Result<HashSet<OutPoint>> {
-        let mut res = HashSet::new();
-
-        let blkhash = spent_filter.block_hash;
-
-        // first get the 8-byte hashes used to construct the input filter
-        let input_hashes_map = self.get_input_hashes(blkhash)?;
-
-        // check against filter
-        let blkfilter = BlockFilter::new(&spent_filter.data);
-        let matched_inputs = self.check_block_inputs(
-            blkfilter,
-            blkhash,
-            input_hashes_map.keys().cloned().collect(),
-        )?;
-
-        // if match: download spent data, collect the outpoints that are spent
-        if matched_inputs {
-            info!("matched inputs on: {}", blkheight);
-            let spent = self.backend.spent_index(blkheight).await?.data;
-
-            for spent in spent {
-                let hex: &[u8] = spent.as_ref();
-
-                if let Some(outpoint) = input_hashes_map.get(hex) {
-                    res.insert(*outpoint);
-                }
-            }
-        }
-        Ok(res)
-    }
-
-    async fn scan_utxos(
-        &self,
-        blkheight: Height,
-        secrets_map: HashMap<[u8; 34], PublicKey>,
-    ) -> Result<Vec<(Option<Label>, UtxoData, Scalar)>> {
-        let utxos = self.backend.utxos(blkheight).await?;
-
-        let mut res: Vec<(Option<Label>, UtxoData, Scalar)> = vec![];
-
-        // group utxos by the txid
-        let mut txmap: HashMap<Txid, Vec<UtxoData>> = HashMap::new();
-        for utxo in utxos {
-            txmap.entry(utxo.txid).or_default().push(utxo);
-        }
-
-        for utxos in txmap.into_values() {
-            // check if we know the secret to any of the spks
-            let mut secret = None;
-            for utxo in utxos.iter() {
-                let spk = utxo.scriptpubkey.as_bytes();
-                if let Some(s) = secrets_map.get(spk) {
-                    secret = Some(s);
-                    break;
-                }
-            }
-
-            // skip this tx if no secret is found
-            let secret = match secret {
-                Some(secret) => secret,
-                None => continue,
-            };
-
-            let output_keys: Result<Vec<XOnlyPublicKey>> = utxos
-                .iter()
-                .filter_map(|x| {
-                    if x.scriptpubkey.is_p2tr() {
-                        Some(
-                            XOnlyPublicKey::from_slice(&x.scriptpubkey.as_bytes()[2..])
-                                .map_err(Error::new),
-                        )
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-
-            let ours = self
-                .client
-                .sp_receiver
-                .scan_transaction(secret, output_keys?)?;
-
-            for utxo in utxos {
-                if !utxo.scriptpubkey.is_p2tr() || utxo.spent {
-                    continue;
-                }
-
-                match XOnlyPublicKey::from_slice(&utxo.scriptpubkey.as_bytes()[2..]) {
-                    Ok(xonly) => {
-                        for (label, map) in ours.iter() {
-                            if let Some(scalar) = map.get(&xonly) {
-                                res.push((label.clone(), utxo, *scalar));
-                                break;
-                            }
-                        }
-                    }
-                    Err(_) => todo!(),
-                }
-            }
-        }
-
-        Ok(res)
-    }
-
-    // Check if this block contains relevant transactions
-    fn check_block_outputs(
-        created_utxo_filter: BlockFilter,
-        blkhash: BlockHash,
-        candidate_spks: Vec<&[u8; 34]>,
-    ) -> Result<bool> {
-        // check output scripts
-        let output_keys: Vec<_> = candidate_spks
-            .into_iter()
-            .map(|spk| spk[2..].as_ref())
-            .collect();
-
-        // note: match will always return true for an empty query!
-        if !output_keys.is_empty() {
-            Ok(created_utxo_filter.match_any(&blkhash, &mut output_keys.into_iter())?)
-        } else {
-            Ok(false)
-        }
-    }
-
-    fn get_input_hashes(&self, blkhash: BlockHash) -> Result<HashMap<[u8; 8], OutPoint>> {
-        let mut map: HashMap<[u8; 8], OutPoint> = HashMap::new();
-
-        for outpoint in &self.owned_outpoints {
-            let mut arr = [0u8; 68];
-            arr[..32].copy_from_slice(&outpoint.txid.to_raw_hash().to_byte_array());
-            arr[32..36].copy_from_slice(&outpoint.vout.to_le_bytes());
-            arr[36..].copy_from_slice(&blkhash.to_byte_array());
-            let hash = sha256::Hash::hash(&arr);
-
-            let mut res = [0u8; 8];
-            res.copy_from_slice(&hash[..8]);
-
-            map.insert(res, outpoint.clone());
-        }
-
-        Ok(map)
-    }
-
-    // Check if this block contains relevant transactions
-    fn check_block_inputs(
-        &self,
-        spent_filter: BlockFilter,
-        blkhash: BlockHash,
-        input_hashes: Vec<[u8; 8]>,
-    ) -> Result<bool> {
-        // note: match will always return true for an empty query!
-        if !input_hashes.is_empty() {
-            Ok(spent_filter.match_any(&blkhash, &mut input_hashes.into_iter())?)
-        } else {
-            Ok(false)
-        }
-    }
-
-    fn interrupt_requested(&self) -> bool {
-        !self
-            .keep_scanning
-            .load(std::sync::atomic::Ordering::Relaxed)
-    }
-}

From 3082749c31ea0a84d2e72c8422c8d7762b52ed9a Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Mon, 18 Aug 2025 12:10:48 +0200
Subject: [PATCH 04/18] Separate wasm build

---
 .cargo/config.toml   | 12 ++++++++++++
 Cargo.toml           | 17 +++++++++++++----
 src/client/client.rs |  1 +
 src/lib.rs           | 20 ++++++++++++++------
 4 files changed, 40 insertions(+), 10 deletions(-)
 create mode 100644 .cargo/config.toml

diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 0000000..d9025ec
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,12 @@
+[target.wasm32-unknown-unknown]
+rustflags = [
+    "-C", "target-feature=+crt-static",
+    "-C", "link-arg=--import-memory",
+    "-C", "link-arg=--initial-memory=2097152",
+    "-C", "link-arg=--max-memory=2097152",
+    "-C", "link-arg=--stack-first",
+    "-C", "link-arg=--export-table",
+]
+
+[build]
+target = "wasm32-unknown-unknown" 
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index d8e963a..f0e60a2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,13 +13,22 @@ anyhow = "1.0"
 serde = { version = "1.0.188", features = ["derive"] }
 serde_json = "1.0.107"
 bitcoin = { version = "0.31.1", features = ["serde", "rand", "base64"] }
-rayon = "1.10.0"
 futures = "0.3"
 log = "0.4"
 async-trait = "0.1"
-reqwest = { version = "0.12.4", features = ["rustls-tls", "gzip", "json"], default-features = false, optional = true }
-hex = { version = "0.4.3", features = ["serde"], optional = true }
+hex = { version = "0.4.3", features = ["serde"] }
 bdk_coin_select = "0.4.0"
 
+# WASM-incompatible dependencies - only include when not targeting WASM
+rayon = { version = "1.10.0", optional = true }
+reqwest = { version = "0.12.4", features = ["rustls-tls", "gzip", "json"], default-features = false, optional = true }
+
+# WASM-specific dependencies
+wasm-bindgen = { version = "0.2", optional = true }
+
 [features]
-blindbit-backend = ["reqwest", "hex"]
+blindbit-backend = ["reqwest", "rayon"]
+default = []
+
+# WASM-specific features
+wasm = ["wasm-bindgen"]
diff --git a/src/client/client.rs b/src/client/client.rs
index 0a4c1d0..87dedf1 100644
--- a/src/client/client.rs
+++ b/src/client/client.rs
@@ -104,6 +104,7 @@ impl SpClient {
         }
     }
 
+    #[cfg(feature = "blindbit-backend")]
     pub fn get_script_to_secret_map(
         &self,
         tweak_data_vec: Vec<PublicKey>,
diff --git a/src/lib.rs b/src/lib.rs
index 2e27d2b..cebd417 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,15 +1,23 @@
-mod backend;
 mod client;
 pub mod constants;
-mod scanner;
-mod updater;
 
 pub use bdk_coin_select::FeeRate;
 pub use bitcoin;
 pub use silentpayments;
 pub use futures;
 
-pub use backend::*;
 pub use client::*;
-pub use scanner::SpScanner;
-pub use updater::Updater;
+
+#[cfg(feature = "blindbit-backend")]
+mod backend;
+#[cfg(feature = "blindbit-backend")]
+mod scanner;
+#[cfg(feature = "blindbit-backend")]
+mod updater;
+
+#[cfg(feature = "blindbit-backend")]
+pub use {
+    backend::*,
+    scanner::SpScanner,
+    updater::Updater,
+};

From 828175deba07589cea047543c559afb64c52eb3a Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Mon, 18 Aug 2025 16:21:47 +0200
Subject: [PATCH 05/18] Migrating to workspace structure

---
 .cargo/config.toml                            |  4 +-
 Cargo.toml                                    | 38 ++++----
 TESTING.md                                    | 90 +++++++++++++++++++
 backend-blindbit-native/Cargo.toml            | 29 ++++++
 .../src}/backend/backend.rs                   |  2 +-
 .../src}/backend/blindbit/backend/backend.rs  |  0
 .../src}/backend/blindbit/backend/mod.rs      |  0
 .../src}/backend/blindbit/client/client.rs    |  0
 .../src}/backend/blindbit/client/mod.rs       |  0
 .../src}/backend/blindbit/client/structs.rs   |  0
 .../src}/backend/blindbit/mod.rs              |  0
 backend-blindbit-native/src/backend/mod.rs    |  6 ++
 .../src}/backend/structs.rs                   |  0
 backend-blindbit-native/src/lib.rs            | 11 +++
 .../src}/scanner/mod.rs                       |  8 +-
 .../src}/updater/mod.rs                       |  0
 .../src}/updater/updater.rs                   |  0
 example-usage.md                              | 74 +++++++++++++++
 sp-client/Cargo.toml                          | 25 ++++++
 {src => sp-client/src}/client/client.rs       | 28 +++++-
 {src => sp-client/src}/client/mod.rs          |  0
 {src => sp-client/src}/client/spend.rs        |  0
 {src => sp-client/src}/client/structs.rs      |  0
 {src => sp-client/src}/constants.rs           |  0
 sp-client/src/lib.rs                          | 13 +++
 sp-client/src/types.rs                        | 26 ++++++
 src/backend/mod.rs                            | 13 ---
 src/lib.rs                                    | 23 -----
 test-compilation.sh                           | 62 +++++++++++++
 29 files changed, 387 insertions(+), 65 deletions(-)
 create mode 100644 TESTING.md
 create mode 100644 backend-blindbit-native/Cargo.toml
 rename {src => backend-blindbit-native/src}/backend/backend.rs (91%)
 rename {src => backend-blindbit-native/src}/backend/blindbit/backend/backend.rs (100%)
 rename {src => backend-blindbit-native/src}/backend/blindbit/backend/mod.rs (100%)
 rename {src => backend-blindbit-native/src}/backend/blindbit/client/client.rs (100%)
 rename {src => backend-blindbit-native/src}/backend/blindbit/client/mod.rs (100%)
 rename {src => backend-blindbit-native/src}/backend/blindbit/client/structs.rs (100%)
 rename {src => backend-blindbit-native/src}/backend/blindbit/mod.rs (100%)
 create mode 100644 backend-blindbit-native/src/backend/mod.rs
 rename {src => backend-blindbit-native/src}/backend/structs.rs (100%)
 create mode 100644 backend-blindbit-native/src/lib.rs
 rename {src => backend-blindbit-native/src}/scanner/mod.rs (98%)
 rename {src => backend-blindbit-native/src}/updater/mod.rs (100%)
 rename {src => backend-blindbit-native/src}/updater/updater.rs (100%)
 create mode 100644 example-usage.md
 create mode 100644 sp-client/Cargo.toml
 rename {src => sp-client/src}/client/client.rs (83%)
 rename {src => sp-client/src}/client/mod.rs (100%)
 rename {src => sp-client/src}/client/spend.rs (100%)
 rename {src => sp-client/src}/client/structs.rs (100%)
 rename {src => sp-client/src}/constants.rs (100%)
 create mode 100644 sp-client/src/lib.rs
 create mode 100644 sp-client/src/types.rs
 delete mode 100644 src/backend/mod.rs
 delete mode 100644 src/lib.rs
 create mode 100755 test-compilation.sh

diff --git a/.cargo/config.toml b/.cargo/config.toml
index d9025ec..125986b 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -8,5 +8,5 @@ rustflags = [
     "-C", "link-arg=--export-table",
 ]
 
-[build]
-target = "wasm32-unknown-unknown" 
\ No newline at end of file
+# [build]
+# target = "wasm32-unknown-unknown"  # Commented out to allow workspace to build for native 
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index f0e60a2..cff9101 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,13 +1,12 @@
-[package]
-name = "sp_client"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-name = "sp_client"
-crate-type = ["lib", "staticlib", "cdylib"]
+[workspace]
+members = [
+    "sp-client",
+    "backend-blindbit-native",
+]
+resolver = "2"
 
-[dependencies]
+[workspace.dependencies]
+# Core dependencies - shared across crates
 silentpayments = "0.4"
 anyhow = "1.0"
 serde = { version = "1.0.188", features = ["derive"] }
@@ -19,16 +18,17 @@ async-trait = "0.1"
 hex = { version = "0.4.3", features = ["serde"] }
 bdk_coin_select = "0.4.0"
 
-# WASM-incompatible dependencies - only include when not targeting WASM
-rayon = { version = "1.10.0", optional = true }
-reqwest = { version = "0.12.4", features = ["rustls-tls", "gzip", "json"], default-features = false, optional = true }
+# Performance dependencies (optional)
+rayon = "1.10.0"
 
-# WASM-specific dependencies
-wasm-bindgen = { version = "0.2", optional = true }
+# Native backend dependencies
+reqwest = { version = "0.12.4", features = ["rustls-tls", "gzip", "json"], default-features = false }
 
-[features]
-blindbit-backend = ["reqwest", "rayon"]
-default = []
+# WASM dependencies (for future use)
+wasm-bindgen = "0.2"
 
-# WASM-specific features
-wasm = ["wasm-bindgen"]
+[workspace.package]
+name = "sp_client"
+version = "0.1.0"
+edition = "2021"
+repository = "https://github.com/cygnet3/sp-client"
diff --git a/TESTING.md b/TESTING.md
new file mode 100644
index 0000000..ccb171a
--- /dev/null
+++ b/TESTING.md
@@ -0,0 +1,90 @@
+# Compilation Testing Guide
+
+This workspace is designed to support multiple architectures with clean separation. Here's how to test all compilation scenarios:
+
+## Quick Test All Scenarios
+
+```bash
+./test-compilation.sh
+```
+
+## Manual Testing Commands
+
+### Core Client Tests
+```bash
+# Default compilation (native)
+cargo check -p sp-client
+
+# With parallel processing feature
+cargo check -p sp-client --features parallel
+
+# No features
+cargo check -p sp-client --no-default-features
+
+# WASM compilation (should work)
+cargo check -p sp-client --target wasm32-unknown-unknown
+```
+
+### Backend Tests
+```bash
+# Native compilation (should work)
+cargo check -p backend-blindbit-native
+
+# WASM compilation (should FAIL)
+cargo check -p backend-blindbit-native --target wasm32-unknown-unknown
+```
+
+### Workspace Tests
+```bash
+# All features
+cargo check --workspace --all-features
+
+# No features
+cargo check --workspace --no-default-features
+
+# Default
+cargo check --workspace
+```
+
+## Expected Results
+
+| Command | Target | Result |
+|---------|--------|--------|
+| `sp-client` | native | ✅ Pass |
+| `sp-client` | wasm32 | ✅ Pass |
+| `backend-blindbit-native` | native | ✅ Pass |
+| `backend-blindbit-native` | wasm32 | ❌ Fail (expected) |
+| `workspace` | native | ✅ Pass |
+
+## Architecture Goals
+
+- **Core client (`sp-client`)**: Architecture-agnostic, minimal dependencies
+- **Native backend (`backend-blindbit-native`)**: Native-only, full functionality
+- **Future WASM backend (`backend-blindbit-wasm`)**: WASM-specific implementation
+- **Future backends**: `backend-electrum-native`, `backend-esplora-native`, etc.
+
+## Feature Flags
+
+- `parallel`: Enable parallel processing in core client (native performance optimization)
+- No backend-specific feature flags needed - use separate crates instead
+
+## CI/CD Integration
+
+Add these commands to your CI pipeline:
+
+```yaml
+# Test all compilation scenarios
+- name: Test compilation scenarios
+  run: ./test-compilation.sh
+
+# Test specific targets
+- name: Test WASM
+  run: cargo check -p sp-client --target wasm32-unknown-unknown
+
+- name: Test native backend fails on WASM
+  run: |
+    if cargo check -p backend-blindbit-native --target wasm32-unknown-unknown; then
+      echo "ERROR: Backend should not compile for WASM"
+      exit 1
+    fi
+```
diff --git a/backend-blindbit-native/Cargo.toml b/backend-blindbit-native/Cargo.toml
new file mode 100644
index 0000000..8744750
--- /dev/null
+++ b/backend-blindbit-native/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "backend-blindbit-native"
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+
+[dependencies]
+# Core client dependency
+sp-client = { path = "../sp-client" }
+
+# Async and futures
+futures.workspace = true
+async-trait.workspace = true
+log.workspace = true
+
+# Native-specific dependencies
+rayon.workspace = true
+reqwest.workspace = true
+
+# Re-export some core types for convenience
+bitcoin.workspace = true
+anyhow.workspace = true
+silentpayments.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+hex.workspace = true
+
+[features]
+default = []
diff --git a/src/backend/backend.rs b/backend-blindbit-native/src/backend/backend.rs
similarity index 91%
rename from src/backend/backend.rs
rename to backend-blindbit-native/src/backend/backend.rs
index d1892f0..a33ebe6 100644
--- a/src/backend/backend.rs
+++ b/backend-blindbit-native/src/backend/backend.rs
@@ -5,7 +5,7 @@ use async_trait::async_trait;
 use bitcoin::{absolute::Height, Amount};
 use futures::Stream;
 
-use super::structs::{BlockData, SpentIndexData, UtxoData};
+use sp_client::{BlockData, SpentIndexData, UtxoData};
 
 #[async_trait]
 pub trait ChainBackend {
diff --git a/src/backend/blindbit/backend/backend.rs b/backend-blindbit-native/src/backend/blindbit/backend/backend.rs
similarity index 100%
rename from src/backend/blindbit/backend/backend.rs
rename to backend-blindbit-native/src/backend/blindbit/backend/backend.rs
diff --git a/src/backend/blindbit/backend/mod.rs b/backend-blindbit-native/src/backend/blindbit/backend/mod.rs
similarity index 100%
rename from src/backend/blindbit/backend/mod.rs
rename to backend-blindbit-native/src/backend/blindbit/backend/mod.rs
diff --git a/src/backend/blindbit/client/client.rs b/backend-blindbit-native/src/backend/blindbit/client/client.rs
similarity index 100%
rename from src/backend/blindbit/client/client.rs
rename to backend-blindbit-native/src/backend/blindbit/client/client.rs
diff --git a/src/backend/blindbit/client/mod.rs b/backend-blindbit-native/src/backend/blindbit/client/mod.rs
similarity index 100%
rename from src/backend/blindbit/client/mod.rs
rename to backend-blindbit-native/src/backend/blindbit/client/mod.rs
diff --git a/src/backend/blindbit/client/structs.rs b/backend-blindbit-native/src/backend/blindbit/client/structs.rs
similarity index 100%
rename from src/backend/blindbit/client/structs.rs
rename to backend-blindbit-native/src/backend/blindbit/client/structs.rs
diff --git a/src/backend/blindbit/mod.rs b/backend-blindbit-native/src/backend/blindbit/mod.rs
similarity index 100%
rename from src/backend/blindbit/mod.rs
rename to backend-blindbit-native/src/backend/blindbit/mod.rs
diff --git a/backend-blindbit-native/src/backend/mod.rs b/backend-blindbit-native/src/backend/mod.rs
new file mode 100644
index 0000000..0e54f10
--- /dev/null
+++ b/backend-blindbit-native/src/backend/mod.rs
@@ -0,0 +1,6 @@
+mod backend;
+mod blindbit;
+
+pub use backend::ChainBackend;
+pub use blindbit::BlindbitBackend;
+pub use blindbit::BlindbitClient;
diff --git a/src/backend/structs.rs b/backend-blindbit-native/src/backend/structs.rs
similarity index 100%
rename from src/backend/structs.rs
rename to backend-blindbit-native/src/backend/structs.rs
diff --git a/backend-blindbit-native/src/lib.rs b/backend-blindbit-native/src/lib.rs
new file mode 100644
index 0000000..83377f1
--- /dev/null
+++ b/backend-blindbit-native/src/lib.rs
@@ -0,0 +1,11 @@
+mod backend;
+mod scanner;
+mod updater;
+
+// Re-export backend functionality
+pub use backend::{ChainBackend, BlindbitBackend, BlindbitClient};
+pub use scanner::SpScanner;
+pub use updater::Updater;
+
+// Re-export core client for convenience
+pub use sp_client::*;
diff --git a/src/scanner/mod.rs b/backend-blindbit-native/src/scanner/mod.rs
similarity index 98%
rename from src/scanner/mod.rs
rename to backend-blindbit-native/src/scanner/mod.rs
index 2ddc51d..140b0c5 100644
--- a/src/scanner/mod.rs
+++ b/backend-blindbit-native/src/scanner/mod.rs
@@ -8,10 +8,10 @@ use bitcoin::{
 use futures::Stream;
 use silentpayments::receiving::Label;
 
-use crate::{
-    backend::{BlockData, FilterData, UtxoData},
-    client::{OwnedOutput, SpClient},
-    updater::Updater,
+use crate::updater::Updater;
+
+use sp_client::{
+    BlockData, FilterData, UtxoData, OwnedOutput, SpClient,
 };
 
 use crate::backend::ChainBackend;
diff --git a/src/updater/mod.rs b/backend-blindbit-native/src/updater/mod.rs
similarity index 100%
rename from src/updater/mod.rs
rename to backend-blindbit-native/src/updater/mod.rs
diff --git a/src/updater/updater.rs b/backend-blindbit-native/src/updater/updater.rs
similarity index 100%
rename from src/updater/updater.rs
rename to backend-blindbit-native/src/updater/updater.rs
diff --git a/example-usage.md b/example-usage.md
new file mode 100644
index 0000000..4bfae59
--- /dev/null
+++ b/example-usage.md
@@ -0,0 +1,74 @@
+# Usage Examples
+
+## For Published Crates (crates.io)
+
+### Core Client Only (Most Common)
+```toml
+[dependencies]
+sp-client = { version = "0.1", features = ["parallel"] }
+```
+
+```rust
+use sp_client::*;
+
+fn main() {
+    let client = SpClient::new(scan_sk, spend_key, network)?;
+    let address = client.get_receiving_address();
+    
+    // With parallel feature enabled
+    let script_map = client.get_script_to_secret_map(tweaks)?;
+}
+```
+
+### Core Client + Native Backend
+```toml
+[dependencies]
+sp-client = "0.1"
+backend-blindbit-native = "0.1"
+```
+
+```rust
+use sp_client::*;
+use backend_blindbit_native::*;
+
+fn main() {
+    // Core client functionality
+    let client = SpClient::new(scan_sk, spend_key, network)?;
+    
+    // Backend functionality
+    let backend = BlindbitBackend::new(host_url)?;
+    let scanner = SomeScanner::new(client, backend);
+}
+```
+
+### WASM Projects
+```toml
+[dependencies]
+sp-client = { version = "0.1", default-features = false }
+# Note: No backend - only core client works in WASM
+```
+
+```rust
+use sp_client::*;
+
+// Only core client functionality available
+let client = SpClient::new(scan_sk, spend_key, network)?;
+let address = client.get_receiving_address();
+// get_script_to_secret_map() not available without "parallel" feature
+```
+
+## For Local Development (Git Dependencies)
+
+### Using Git Repository
+```toml
+[dependencies]
+sp-client = { git = "https://github.com/your-org/sp-client", features = ["parallel"] }
+backend-blindbit-native = { git = "https://github.com/your-org/sp-client" }
+```
+
+### Using Local Path
+```toml
+[dependencies]
+sp-client = { path = "../sp-client/sp-client", features = ["parallel"] }
+backend-blindbit-native = { path = "../sp-client/backend-blindbit-native" }
+```
diff --git a/sp-client/Cargo.toml b/sp-client/Cargo.toml
new file mode 100644
index 0000000..5aa350c
--- /dev/null
+++ b/sp-client/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "sp-client"
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+
+[lib]
+crate-type = ["lib", "staticlib", "cdylib"]
+
+[dependencies]
+# Core dependencies - always available
+silentpayments.workspace = true
+anyhow.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+bitcoin.workspace = true
+hex.workspace = true
+bdk_coin_select.workspace = true
+
+# Optional for performance optimization
+rayon = { workspace = true, optional = true }
+
+[features]
+default = []
+parallel = ["rayon"]  # Enable parallel processing for better performance
diff --git a/src/client/client.rs b/sp-client/src/client/client.rs
similarity index 83%
rename from src/client/client.rs
rename to sp-client/src/client/client.rs
index 87dedf1..11c715c 100644
--- a/src/client/client.rs
+++ b/sp-client/src/client/client.rs
@@ -1,14 +1,17 @@
-use std::{collections::HashMap, io::Write, str::FromStr};
+use std::{io::Write, str::FromStr};
 
 use bitcoin::hashes::Hash;
 use bitcoin::{
     key::constants::ONE,
-    secp256k1::{PublicKey, Scalar, Secp256k1, SecretKey},
+    secp256k1::{Scalar, Secp256k1, SecretKey},
     Network, XOnlyPublicKey,
 };
 use serde::{Deserialize, Serialize};
 
+use std::collections::HashMap;
+use bitcoin::secp256k1::PublicKey;
 use silentpayments::utils as sp_utils;
+
 use silentpayments::Network as SpNetwork;
 use silentpayments::{
     bitcoin_hashes::sha256,
@@ -104,19 +107,28 @@ impl SpClient {
         }
     }
 
-    #[cfg(feature = "blindbit-backend")]
     pub fn get_script_to_secret_map(
         &self,
         tweak_data_vec: Vec<PublicKey>,
     ) -> Result<HashMap<[u8; 34], PublicKey>> {
+        #[cfg(feature = "parallel")]
         use rayon::prelude::*;
+
         let b_scan = &self.get_scan_key();
 
+        #[cfg(feature = "parallel")]
         let shared_secrets: Vec<PublicKey> = tweak_data_vec
             .into_par_iter()
             .map(|tweak| sp_utils::receiving::calculate_ecdh_shared_secret(&tweak, b_scan))
             .collect();
 
+        #[cfg(not(feature = "parallel"))]
+        let shared_secrets: Vec<PublicKey> = tweak_data_vec
+            .into_iter()
+            .map(|tweak| sp_utils::receiving::calculate_ecdh_shared_secret(&tweak, b_scan))
+            .collect();
+
+        #[cfg(feature = "parallel")]
         let items: Result<Vec<_>> = shared_secrets
             .into_par_iter()
             .map(|secret| {
@@ -126,6 +138,16 @@ impl SpClient {
             })
             .collect();
 
+        #[cfg(not(feature = "parallel"))]
+        let items: Result<Vec<_>> = shared_secrets
+            .into_iter()
+            .map(|secret| {
+                let spks = self.sp_receiver.get_spks_from_shared_secret(&secret)?;
+
+                Ok((secret, spks.into_values()))
+            })
+            .collect();
+
         let mut res = HashMap::new();
         for (secret, spks) in items? {
             for spk in spks {
diff --git a/src/client/mod.rs b/sp-client/src/client/mod.rs
similarity index 100%
rename from src/client/mod.rs
rename to sp-client/src/client/mod.rs
diff --git a/src/client/spend.rs b/sp-client/src/client/spend.rs
similarity index 100%
rename from src/client/spend.rs
rename to sp-client/src/client/spend.rs
diff --git a/src/client/structs.rs b/sp-client/src/client/structs.rs
similarity index 100%
rename from src/client/structs.rs
rename to sp-client/src/client/structs.rs
diff --git a/src/constants.rs b/sp-client/src/constants.rs
similarity index 100%
rename from src/constants.rs
rename to sp-client/src/constants.rs
diff --git a/sp-client/src/lib.rs b/sp-client/src/lib.rs
new file mode 100644
index 0000000..0018513
--- /dev/null
+++ b/sp-client/src/lib.rs
@@ -0,0 +1,13 @@
+pub mod client;
+pub mod constants;
+pub mod types;
+
+// Re-export core functionality
+pub use client::*;
+pub use constants::*;
+pub use types::*;
+
+// Re-export commonly used external types
+pub use bdk_coin_select::FeeRate;
+pub use bitcoin;
+pub use silentpayments;
diff --git a/sp-client/src/types.rs b/sp-client/src/types.rs
new file mode 100644
index 0000000..b5ee039
--- /dev/null
+++ b/sp-client/src/types.rs
@@ -0,0 +1,26 @@
+use bitcoin::{absolute::Height, secp256k1::PublicKey, Amount, BlockHash, ScriptBuf, Txid};
+
+pub struct BlockData {
+    pub blkheight: Height,
+    pub blkhash: BlockHash,
+    pub tweaks: Vec<PublicKey>,
+    pub new_utxo_filter: FilterData,
+    pub spent_filter: FilterData,
+}
+
+pub struct UtxoData {
+    pub txid: Txid,
+    pub vout: u32,
+    pub value: Amount,
+    pub scriptpubkey: ScriptBuf,
+    pub spent: bool,
+}
+
+pub struct SpentIndexData {
+    pub data: Vec<Vec<u8>>,
+}
+
+pub struct FilterData {
+    pub block_hash: BlockHash,
+    pub data: Vec<u8>,
+}
diff --git a/src/backend/mod.rs b/src/backend/mod.rs
deleted file mode 100644
index d81e60c..0000000
--- a/src/backend/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-mod backend;
-#[cfg(feature = "blindbit-backend")]
-mod blindbit;
-mod structs;
-
-pub use backend::ChainBackend;
-pub use structs::*;
-
-#[cfg(feature = "blindbit-backend")]
-pub use blindbit::BlindbitBackend;
-
-#[cfg(feature = "blindbit-backend")]
-pub use blindbit::BlindbitClient;
diff --git a/src/lib.rs b/src/lib.rs
deleted file mode 100644
index cebd417..0000000
--- a/src/lib.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-mod client;
-pub mod constants;
-
-pub use bdk_coin_select::FeeRate;
-pub use bitcoin;
-pub use silentpayments;
-pub use futures;
-
-pub use client::*;
-
-#[cfg(feature = "blindbit-backend")]
-mod backend;
-#[cfg(feature = "blindbit-backend")]
-mod scanner;
-#[cfg(feature = "blindbit-backend")]
-mod updater;
-
-#[cfg(feature = "blindbit-backend")]
-pub use {
-    backend::*,
-    scanner::SpScanner,
-    updater::Updater,
-};
diff --git a/test-compilation.sh b/test-compilation.sh
new file mode 100755
index 0000000..242aa29
--- /dev/null
+++ b/test-compilation.sh
@@ -0,0 +1,62 @@
+#!/bin/bash
+
+set -e  # Exit on any error
+
+echo "🧪 Testing All Compilation Scenarios"
+echo "===================================="
+
+echo ""
+echo "✅ 1. Testing workspace with all features..."
+cargo check --workspace --all-features
+
+echo ""
+echo "✅ 2. Testing workspace with no features..."
+cargo check --workspace --no-default-features
+
+echo ""
+echo "✅ 3. Testing core client only (default)..."
+cargo check -p sp-client
+
+echo ""
+echo "✅ 4. Testing core client with parallel feature..."
+cargo check -p sp-client --features parallel
+
+echo ""
+echo "✅ 5. Testing core client without features..."
+cargo check -p sp-client --no-default-features
+
+echo ""
+echo "✅ 6. Testing backend only..."
+cargo check -p backend-blindbit-native
+
+echo ""
+echo "✅ 7. Testing core client for WASM..."
+cargo check -p sp-client --target wasm32-unknown-unknown
+
+echo ""
+echo "✅ 8. Testing core client for WASM (with no features)..."
+cargo check -p sp-client --target wasm32-unknown-unknown --no-default-features
+
+echo ""
+echo "❌ 9. Testing that backend FAILS for WASM (expected to fail)..."
+if cargo check -p backend-blindbit-native --target wasm32-unknown-unknown 2>/dev/null; then
+    echo "ERROR: Backend should NOT compile for WASM!"
+    exit 1
+else
+    echo "✅ Good! Backend correctly fails to compile for WASM"
+fi
+
+echo ""
+echo "✅ 10. Testing build (not just check)..."
+cargo build --workspace --all-features
+
+echo ""
+echo "🎉 All compilation tests passed!"
+echo ""
+echo "Summary:"
+echo "--------"
+echo "✅ Core client compiles for native and WASM"
+echo "✅ Core client works with and without features"
+echo "✅ Backend compiles for native only"
+echo "❌ Backend correctly fails for WASM"
+echo "✅ Workspace supports all feature combinations"

From 650a2929c695246088267984ce25956bfacc143b Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Mon, 18 Aug 2025 16:40:51 +0200
Subject: [PATCH 06/18] Move Updated to core

---
 backend-blindbit-native/src/lib.rs                            | 4 +---
 backend-blindbit-native/src/scanner/mod.rs                    | 4 ++--
 sp-client/src/lib.rs                                          | 2 ++
 {backend-blindbit-native => sp-client}/src/updater/mod.rs     | 0
 {backend-blindbit-native => sp-client}/src/updater/updater.rs | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)
 rename {backend-blindbit-native => sp-client}/src/updater/mod.rs (100%)
 rename {backend-blindbit-native => sp-client}/src/updater/updater.rs (96%)

diff --git a/backend-blindbit-native/src/lib.rs b/backend-blindbit-native/src/lib.rs
index 83377f1..00bc7a7 100644
--- a/backend-blindbit-native/src/lib.rs
+++ b/backend-blindbit-native/src/lib.rs
@@ -1,11 +1,9 @@
 mod backend;
 mod scanner;
-mod updater;
 
 // Re-export backend functionality
 pub use backend::{ChainBackend, BlindbitBackend, BlindbitClient};
 pub use scanner::SpScanner;
-pub use updater::Updater;
 
-// Re-export core client for convenience
+// Re-export core client for convenience (includes Updater)
 pub use sp_client::*;
diff --git a/backend-blindbit-native/src/scanner/mod.rs b/backend-blindbit-native/src/scanner/mod.rs
index 140b0c5..fe62c6f 100644
--- a/backend-blindbit-native/src/scanner/mod.rs
+++ b/backend-blindbit-native/src/scanner/mod.rs
@@ -8,10 +8,10 @@ use bitcoin::{
 use futures::Stream;
 use silentpayments::receiving::Label;
 
-use crate::updater::Updater;
+// Updater now comes from sp-client
 
 use sp_client::{
-    BlockData, FilterData, UtxoData, OwnedOutput, SpClient,
+    BlockData, FilterData, UtxoData, OwnedOutput, SpClient, Updater,
 };
 
 use crate::backend::ChainBackend;
diff --git a/sp-client/src/lib.rs b/sp-client/src/lib.rs
index 0018513..457bca5 100644
--- a/sp-client/src/lib.rs
+++ b/sp-client/src/lib.rs
@@ -1,11 +1,13 @@
 pub mod client;
 pub mod constants;
 pub mod types;
+pub mod updater;
 
 // Re-export core functionality
 pub use client::*;
 pub use constants::*;
 pub use types::*;
+pub use updater::Updater;
 
 // Re-export commonly used external types
 pub use bdk_coin_select::FeeRate;
diff --git a/backend-blindbit-native/src/updater/mod.rs b/sp-client/src/updater/mod.rs
similarity index 100%
rename from backend-blindbit-native/src/updater/mod.rs
rename to sp-client/src/updater/mod.rs
diff --git a/backend-blindbit-native/src/updater/updater.rs b/sp-client/src/updater/updater.rs
similarity index 96%
rename from backend-blindbit-native/src/updater/updater.rs
rename to sp-client/src/updater/updater.rs
index 28ff001..f8abb87 100644
--- a/backend-blindbit-native/src/updater/updater.rs
+++ b/sp-client/src/updater/updater.rs
@@ -4,7 +4,7 @@ use bitcoin::{absolute::Height, BlockHash, OutPoint};
 
 use anyhow::Result;
 
-use crate::client::OwnedOutput;
+use crate::OwnedOutput;
 
 pub trait Updater {
     /// Ask the updater to record the scanning progress.

From 9587d7211188d84e5adeffa103c48d3071bb9b89 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Mon, 18 Aug 2025 16:57:10 +0200
Subject: [PATCH 07/18] package name fix

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index cff9101..0a563c1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,7 +28,7 @@ reqwest = { version = "0.12.4", features = ["rustls-tls", "gzip", "json"], defau
 wasm-bindgen = "0.2"
 
 [workspace.package]
-name = "sp_client"
+name = "sp-client"
 version = "0.1.0"
 edition = "2021"
 repository = "https://github.com/cygnet3/sp-client"

From 1f0034d8112f21aafbd30849b3046fe0f8b13364 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Thu, 21 Aug 2025 20:07:00 +0200
Subject: [PATCH 08/18] Remove dummy implementation of get_input_hashes

---
 backend-blindbit-native/src/scanner/mod.rs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/backend-blindbit-native/src/scanner/mod.rs b/backend-blindbit-native/src/scanner/mod.rs
index fe62c6f..3bd611d 100644
--- a/backend-blindbit-native/src/scanner/mod.rs
+++ b/backend-blindbit-native/src/scanner/mod.rs
@@ -2,7 +2,7 @@ use std::collections::{HashMap, HashSet};
 
 use anyhow::{Error, Result};
 use bitcoin::{
-    absolute::Height, bip158::BlockFilter, hashes::{sha256, Hash}, 
+    absolute::Height, bip158::BlockFilter, 
     Amount, BlockHash, OutPoint, Txid, XOnlyPublicKey
 };
 use futures::Stream;
@@ -308,13 +308,7 @@ pub trait SpScanner {
     /// Get input hashes for owned outpoints
     /// 
     /// This is a default implementation that can be overridden if needed
-    fn get_input_hashes(&self, blkhash: BlockHash) -> Result<HashMap<[u8; 8], OutPoint>> {
-        let mut map: HashMap<[u8; 8], OutPoint> = HashMap::new();
-
-        // This method needs access to owned_outpoints, which should be provided by the implementor
-        // For now, we'll return an empty map - implementors should override this method
-        Ok(map)
-    }
+    fn get_input_hashes(&self, blkhash: BlockHash) -> Result<HashMap<[u8; 8], OutPoint>>;
 
     /// Check if block contains relevant input transactions
     /// 

From 32c33f28bea9562a599269eb375e452aeebd1820 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Fri, 22 Aug 2025 10:14:47 +0200
Subject: [PATCH 09/18] Remove dead code

---
 .../src/backend/structs.rs                    | 26 -------------------
 1 file changed, 26 deletions(-)
 delete mode 100644 backend-blindbit-native/src/backend/structs.rs

diff --git a/backend-blindbit-native/src/backend/structs.rs b/backend-blindbit-native/src/backend/structs.rs
deleted file mode 100644
index b5ee039..0000000
--- a/backend-blindbit-native/src/backend/structs.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use bitcoin::{absolute::Height, secp256k1::PublicKey, Amount, BlockHash, ScriptBuf, Txid};
-
-pub struct BlockData {
-    pub blkheight: Height,
-    pub blkhash: BlockHash,
-    pub tweaks: Vec<PublicKey>,
-    pub new_utxo_filter: FilterData,
-    pub spent_filter: FilterData,
-}
-
-pub struct UtxoData {
-    pub txid: Txid,
-    pub vout: u32,
-    pub value: Amount,
-    pub scriptpubkey: ScriptBuf,
-    pub spent: bool,
-}
-
-pub struct SpentIndexData {
-    pub data: Vec<Vec<u8>>,
-}
-
-pub struct FilterData {
-    pub block_hash: BlockHash,
-    pub data: Vec<u8>,
-}

From a3428f4d9acff0e164bce136e483f2ed1d197056 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Fri, 22 Aug 2025 10:15:50 +0200
Subject: [PATCH 10/18] Add the blindbit wasm crate

---
 Cargo.toml                                    |   1 +
 backend-blindbit-wasm/Cargo.toml              |  33 ++
 backend-blindbit-wasm/src/backend/backend.rs  |  24 ++
 .../src/backend/blindbit/backend/backend.rs   |  84 +++++
 .../src/backend/blindbit/backend/mod.rs       |   3 +
 .../src/backend/blindbit/client/client.rs     | 124 +++++++
 .../src/backend/blindbit/client/mod.rs        |   4 +
 .../src/backend/blindbit/client/structs.rs    | 103 ++++++
 .../src/backend/blindbit/mod.rs               |   5 +
 backend-blindbit-wasm/src/backend/mod.rs      |   6 +
 backend-blindbit-wasm/src/lib.rs              |  34 ++
 backend-blindbit-wasm/src/scanner/mod.rs      | 329 ++++++++++++++++++
 12 files changed, 750 insertions(+)
 create mode 100644 backend-blindbit-wasm/Cargo.toml
 create mode 100644 backend-blindbit-wasm/src/backend/backend.rs
 create mode 100644 backend-blindbit-wasm/src/backend/blindbit/backend/backend.rs
 create mode 100644 backend-blindbit-wasm/src/backend/blindbit/backend/mod.rs
 create mode 100644 backend-blindbit-wasm/src/backend/blindbit/client/client.rs
 create mode 100644 backend-blindbit-wasm/src/backend/blindbit/client/mod.rs
 create mode 100644 backend-blindbit-wasm/src/backend/blindbit/client/structs.rs
 create mode 100644 backend-blindbit-wasm/src/backend/blindbit/mod.rs
 create mode 100644 backend-blindbit-wasm/src/backend/mod.rs
 create mode 100644 backend-blindbit-wasm/src/lib.rs
 create mode 100644 backend-blindbit-wasm/src/scanner/mod.rs

diff --git a/Cargo.toml b/Cargo.toml
index 0a563c1..27b099c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,6 +2,7 @@
 members = [
     "sp-client",
     "backend-blindbit-native",
+    "backend-blindbit-wasm",
 ]
 resolver = "2"
 
diff --git a/backend-blindbit-wasm/Cargo.toml b/backend-blindbit-wasm/Cargo.toml
new file mode 100644
index 0000000..560a80f
--- /dev/null
+++ b/backend-blindbit-wasm/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "backend-blindbit-wasm"
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+description = "WASM-only Blindbit backend - compile with --target wasm32-unknown-unknown"
+
+[dependencies]
+# Core client dependency
+sp-client = { path = "../sp-client" }
+
+# Async and futures
+futures.workspace = true
+async-trait.workspace = true
+log.workspace = true
+
+# WASM-specific dependencies
+wasm-bindgen.workspace = true
+wasm-bindgen-futures = "0.4"
+
+# HTTP client for WASM
+reqwest = { version = "0.12", features = ["json"], default-features = false }
+
+# Re-export some core types for convenience
+bitcoin.workspace = true
+anyhow.workspace = true
+silentpayments.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+hex.workspace = true
+
+[features]
+default = []
diff --git a/backend-blindbit-wasm/src/backend/backend.rs b/backend-blindbit-wasm/src/backend/backend.rs
new file mode 100644
index 0000000..dc9b976
--- /dev/null
+++ b/backend-blindbit-wasm/src/backend/backend.rs
@@ -0,0 +1,24 @@
+use std::{ops::RangeInclusive, pin::Pin};
+
+use anyhow::Result;
+use async_trait::async_trait;
+use bitcoin::{absolute::Height, Amount};
+use futures::Stream;
+
+use sp_client::{BlockData, SpentIndexData, UtxoData};
+
+#[async_trait(?Send)]
+pub trait ChainBackend {
+    fn get_block_data_for_range(
+        &self,
+        range: RangeInclusive<u32>,
+        dust_limit: Amount,
+        with_cutthrough: bool,
+    ) -> Pin<Box<dyn Stream<Item = Result<BlockData>>>>;
+
+    async fn spent_index(&self, block_height: Height) -> Result<SpentIndexData>;
+
+    async fn utxos(&self, block_height: Height) -> Result<Vec<UtxoData>>;
+
+    async fn block_height(&self) -> Result<Height>;
+}
diff --git a/backend-blindbit-wasm/src/backend/blindbit/backend/backend.rs b/backend-blindbit-wasm/src/backend/blindbit/backend/backend.rs
new file mode 100644
index 0000000..ff902d2
--- /dev/null
+++ b/backend-blindbit-wasm/src/backend/blindbit/backend/backend.rs
@@ -0,0 +1,84 @@
+use std::{ops::RangeInclusive, pin::Pin, sync::Arc};
+
+use async_trait::async_trait;
+use bitcoin::{absolute::Height, Amount};
+use futures::{stream, Stream, StreamExt};
+
+use anyhow::Result;
+
+use crate::{backend::blindbit::BlindbitClient, BlockData, ChainBackend, SpentIndexData, UtxoData};
+
+const CONCURRENT_FILTER_REQUESTS: usize = 200;
+
+#[derive(Debug)]
+pub struct BlindbitBackend {
+    client: BlindbitClient,
+}
+
+impl BlindbitBackend {
+    pub fn new(blindbit_url: String) -> Result<Self> {
+        Ok(Self {
+            client: BlindbitClient::new(blindbit_url)?,
+        })
+    }
+}
+
+#[async_trait(?Send)]
+impl ChainBackend for BlindbitBackend {
+    /// High-level function to get block data for a range of blocks.
+    /// Block data includes all the information needed to determine if a block is relevant for scanning,
+    /// but does not include utxos, or spent index.
+    /// These need to be fetched separately afterwards, if it is determined this block is relevant.
+    fn get_block_data_for_range(
+        &self,
+        range: RangeInclusive<u32>,
+        dust_limit: Amount,
+        with_cutthrough: bool,
+    ) -> Pin<Box<dyn Stream<Item = Result<BlockData>>>> {
+        let client = Arc::new(self.client.clone());
+
+        let res = stream::iter(range)
+            .map(move |n| {
+                let client = client.clone();
+
+                async move {
+                    let blkheight = Height::from_consensus(n)?;
+                    let tweaks = match with_cutthrough {
+                        true => client.tweaks(blkheight, dust_limit).await?,
+                        false => client.tweak_index(blkheight, dust_limit).await?,
+                    };
+                    let new_utxo_filter = client.filter_new_utxos(blkheight).await?;
+                    let spent_filter = client.filter_spent(blkheight).await?;
+                    let blkhash = new_utxo_filter.block_hash;
+                    Ok(BlockData {
+                        blkheight,
+                        blkhash,
+                        tweaks,
+                        new_utxo_filter: new_utxo_filter.into(),
+                        spent_filter: spent_filter.into(),
+                    })
+                }
+            })
+            .buffered(CONCURRENT_FILTER_REQUESTS);
+
+        Box::pin(res)
+    }
+
+    async fn spent_index(&self, block_height: Height) -> Result<SpentIndexData> {
+        self.client.spent_index(block_height).await.map(Into::into)
+    }
+
+    async fn utxos(&self, block_height: Height) -> Result<Vec<UtxoData>> {
+        Ok(self
+            .client
+            .utxos(block_height)
+            .await?
+            .into_iter()
+            .map(Into::into)
+            .collect())
+    }
+
+    async fn block_height(&self) -> Result<Height> {
+        self.client.block_height().await
+    }
+}
diff --git a/backend-blindbit-wasm/src/backend/blindbit/backend/mod.rs b/backend-blindbit-wasm/src/backend/blindbit/backend/mod.rs
new file mode 100644
index 0000000..e48b365
--- /dev/null
+++ b/backend-blindbit-wasm/src/backend/blindbit/backend/mod.rs
@@ -0,0 +1,3 @@
+mod backend;
+
+pub use backend::BlindbitBackend;
diff --git a/backend-blindbit-wasm/src/backend/blindbit/client/client.rs b/backend-blindbit-wasm/src/backend/blindbit/client/client.rs
new file mode 100644
index 0000000..b42b5bd
--- /dev/null
+++ b/backend-blindbit-wasm/src/backend/blindbit/client/client.rs
@@ -0,0 +1,124 @@
+use bitcoin::{absolute::Height, secp256k1::PublicKey, Amount, Txid};
+use reqwest::{Client, Url};
+use anyhow::Result;
+
+use crate::backend::blindbit::client::structs::InfoResponse;
+
+use super::structs::{
+    BlockHeightResponse, FilterResponse, ForwardTxRequest, SpentIndexResponse, UtxoResponse,
+};
+
+#[derive(Clone, Debug)]
+pub struct BlindbitClient {
+    client: Client,
+    host_url: Url,
+}
+
+impl BlindbitClient {
+    pub fn new(host_url: String) -> Result<Self> {
+        let mut host_url = Url::parse(&host_url)?;
+        let client = reqwest::Client::new();
+
+        // we need a trailing slash, if not present we append it
+        if !host_url.path().ends_with('/') {
+            host_url.set_path(&format!("{}/", host_url.path()));
+        }
+
+        Ok(BlindbitClient { client, host_url })
+    }
+
+    pub async fn block_height(&self) -> Result<Height> {
+        let url = self.host_url.join("block-height")?;
+
+        let res = self
+            .client
+            .get(url)
+            .send()
+            .await?;
+        let blkheight: BlockHeightResponse = serde_json::from_str(&res.text().await?)?;
+        Ok(blkheight.block_height)
+    }
+
+    pub async fn tweaks(&self, block_height: Height, dust_limit: Amount) -> Result<Vec<PublicKey>> {
+        let url = self.host_url.join(&format!("tweaks/{}", block_height))?;
+
+        let res = self
+            .client
+            .get(url)
+            .query(&[("dustLimit", format!("{}", dust_limit.to_sat()))])
+            .send()
+            .await?;
+        Ok(serde_json::from_str(&res.text().await?)?)
+    }
+
+    pub async fn tweak_index(
+        &self,
+        block_height: Height,
+        dust_limit: Amount,
+    ) -> Result<Vec<PublicKey>> {
+        let url = self
+            .host_url
+            .join(&format!("tweak-index/{}", block_height))?;
+
+        let res = self
+            .client
+            .get(url)
+            .query(&[("dustLimit", format!("{}", dust_limit.to_sat()))])
+            .send()
+            .await?;
+        Ok(serde_json::from_str(&res.text().await?)?)
+    }
+
+    pub async fn utxos(&self, block_height: Height) -> Result<Vec<UtxoResponse>> {
+        let url = self.host_url.join(&format!("utxos/{}", block_height))?;
+        let res = self.client.get(url).send().await?;
+
+        Ok(serde_json::from_str(&res.text().await?)?)
+    }
+
+    pub async fn spent_index(&self, block_height: Height) -> Result<SpentIndexResponse> {
+        let url = self
+            .host_url
+            .join(&format!("spent-index/{}", block_height))?;
+        let res = self.client.get(url).send().await?;
+
+        Ok(serde_json::from_str(&res.text().await?)?)
+    }
+
+    pub async fn filter_new_utxos(&self, block_height: Height) -> Result<FilterResponse> {
+        let url = self
+            .host_url
+            .join(&format!("filter/new-utxos/{}", block_height))?;
+
+        let res = self.client.get(url).send().await?;
+
+        Ok(serde_json::from_str(&res.text().await?)?)
+    }
+
+    pub async fn filter_spent(&self, block_height: Height) -> Result<FilterResponse> {
+        let url = self
+            .host_url
+            .join(&format!("filter/spent/{}", block_height))?;
+
+        let res = self.client.get(url).send().await?;
+
+        Ok(serde_json::from_str(&res.text().await?)?)
+    }
+
+    pub async fn forward_tx(&self, tx_hex: String) -> Result<Txid> {
+        let url = self.host_url.join("forward-tx")?;
+
+        let body = ForwardTxRequest::new(tx_hex);
+
+        let res = self.client.post(url).json(&body).send().await?;
+
+        Ok(serde_json::from_str(&res.text().await?)?)
+    }
+
+    pub async fn info(&self) -> Result<InfoResponse> {
+        let url = self.host_url.join("info")?;
+
+        let res = self.client.get(url).send().await?;
+        Ok(serde_json::from_str(&res.text().await?)?)
+    }
+}
diff --git a/backend-blindbit-wasm/src/backend/blindbit/client/mod.rs b/backend-blindbit-wasm/src/backend/blindbit/client/mod.rs
new file mode 100644
index 0000000..82f00d4
--- /dev/null
+++ b/backend-blindbit-wasm/src/backend/blindbit/client/mod.rs
@@ -0,0 +1,4 @@
+mod client;
+pub mod structs;
+
+pub use client::BlindbitClient;
diff --git a/backend-blindbit-wasm/src/backend/blindbit/client/structs.rs b/backend-blindbit-wasm/src/backend/blindbit/client/structs.rs
new file mode 100644
index 0000000..e4c3f13
--- /dev/null
+++ b/backend-blindbit-wasm/src/backend/blindbit/client/structs.rs
@@ -0,0 +1,103 @@
+#![allow(dead_code)]
+use bitcoin::{absolute::Height, Amount, BlockHash, Network, ScriptBuf, Txid};
+use serde::{Deserialize, Deserializer, Serialize};
+
+use crate::{FilterData, SpentIndexData, UtxoData};
+
+#[derive(Debug, Deserialize)]
+pub struct BlockHeightResponse {
+    pub block_height: Height,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct UtxoResponse {
+    pub txid: Txid,
+    pub vout: u32,
+    pub value: Amount,
+    pub scriptpubkey: ScriptBuf,
+    pub block_height: Height,
+    pub block_hash: BlockHash,
+    pub timestamp: i32,
+    pub spent: bool,
+}
+
+impl From<UtxoResponse> for UtxoData {
+    fn from(value: UtxoResponse) -> Self {
+        Self {
+            txid: value.txid,
+            vout: value.vout,
+            value: value.value,
+            scriptpubkey: value.scriptpubkey,
+            spent: value.spent,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct SpentIndexResponse {
+    pub block_hash: BlockHash,
+    pub data: Vec<MyHex>,
+}
+
+impl From<SpentIndexResponse> for SpentIndexData {
+    fn from(value: SpentIndexResponse) -> Self {
+        Self {
+            data: value.data.into_iter().map(|x| x.hex).collect(),
+        }
+    }
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(transparent)]
+pub struct MyHex {
+    #[serde(with = "hex::serde")]
+    pub hex: Vec<u8>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct FilterResponse {
+    pub block_hash: BlockHash,
+    pub block_height: Height,
+    pub data: MyHex,
+    pub filter_type: i32,
+}
+
+impl From<FilterResponse> for FilterData {
+    fn from(value: FilterResponse) -> Self {
+        Self {
+            block_hash: value.block_hash,
+            data: value.data.hex,
+        }
+    }
+}
+
+#[derive(Debug, Serialize)]
+pub struct ForwardTxRequest {
+    data: String,
+}
+
+impl ForwardTxRequest {
+    pub fn new(tx_hex: String) -> Self {
+        Self { data: tx_hex }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct InfoResponse {
+    #[serde(deserialize_with = "deserialize_network")]
+    pub network: Network,
+    pub height: Height,
+    pub tweaks_only: bool,
+    pub tweaks_full_basic: bool,
+    pub tweaks_full_with_dust_filter: bool,
+    pub tweaks_cut_through_with_dust_filter: bool,
+}
+
+fn deserialize_network<'de, D>(deserializer: D) -> Result<Network, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let buf = String::deserialize(deserializer)?;
+
+    Network::from_core_arg(&buf).map_err(serde::de::Error::custom)
+}
diff --git a/backend-blindbit-wasm/src/backend/blindbit/mod.rs b/backend-blindbit-wasm/src/backend/blindbit/mod.rs
new file mode 100644
index 0000000..4dc245c
--- /dev/null
+++ b/backend-blindbit-wasm/src/backend/blindbit/mod.rs
@@ -0,0 +1,5 @@
+mod backend;
+mod client;
+
+pub use backend::BlindbitBackend;
+pub use client::BlindbitClient;
diff --git a/backend-blindbit-wasm/src/backend/mod.rs b/backend-blindbit-wasm/src/backend/mod.rs
new file mode 100644
index 0000000..0e54f10
--- /dev/null
+++ b/backend-blindbit-wasm/src/backend/mod.rs
@@ -0,0 +1,6 @@
+mod backend;
+mod blindbit;
+
+pub use backend::ChainBackend;
+pub use blindbit::BlindbitBackend;
+pub use blindbit::BlindbitClient;
diff --git a/backend-blindbit-wasm/src/lib.rs b/backend-blindbit-wasm/src/lib.rs
new file mode 100644
index 0000000..c0c24fc
--- /dev/null
+++ b/backend-blindbit-wasm/src/lib.rs
@@ -0,0 +1,34 @@
+//! # Backend Blindbit WASM
+//! 
+//! **⚠️ WASM-only crate**: This crate is designed specifically for WebAssembly targets.
+//! 
+//! ## Build Requirements
+//! 
+//! This crate must be compiled with the `wasm32-unknown-unknown` target:
+//! 
+//! ```bash
+//! cargo build -p backend-blindbit-wasm --target wasm32-unknown-unknown
+//! ```
+//! 
+//! ## IDE Setup
+//! 
+//! If you see errors in rust-analyzer, it's because it's checking with the native target.
+//! To fix this, you can either:
+//! 
+//! 1. Set your IDE to use the WASM target for this crate
+//! 2. Or ignore the errors - they won't appear when building with the correct target
+//! 
+//! ## HTTP Client
+//! 
+//! This crate uses `reqwest` which automatically uses the browser's `fetch()` API when 
+//! compiled to WebAssembly.
+
+mod backend;
+mod scanner;
+
+// Re-export backend functionality
+pub use backend::{ChainBackend, BlindbitBackend, BlindbitClient};
+pub use scanner::SpScanner;
+
+// Re-export core client for convenience (includes Updater)
+pub use sp_client::*;
diff --git a/backend-blindbit-wasm/src/scanner/mod.rs b/backend-blindbit-wasm/src/scanner/mod.rs
new file mode 100644
index 0000000..3bd611d
--- /dev/null
+++ b/backend-blindbit-wasm/src/scanner/mod.rs
@@ -0,0 +1,329 @@
+use std::collections::{HashMap, HashSet};
+
+use anyhow::{Error, Result};
+use bitcoin::{
+    absolute::Height, bip158::BlockFilter, 
+    Amount, BlockHash, OutPoint, Txid, XOnlyPublicKey
+};
+use futures::Stream;
+use silentpayments::receiving::Label;
+
+// Updater now comes from sp-client
+
+use sp_client::{
+    BlockData, FilterData, UtxoData, OwnedOutput, SpClient, Updater,
+};
+
+use crate::backend::ChainBackend;
+
+/// Trait for scanning silent payment blocks
+/// 
+/// This trait abstracts the core scanning functionality, allowing consumers
+/// to implement it with their own constraints and requirements.
+#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
+pub trait SpScanner {
+    /// Scan a range of blocks for silent payment outputs and inputs
+    /// 
+    /// # Arguments
+    /// * `start` - Starting block height (inclusive)
+    /// * `end` - Ending block height (inclusive)
+    /// * `dust_limit` - Minimum amount to consider (dust outputs are ignored)
+    /// * `with_cutthrough` - Whether to use cutthrough optimization
+    async fn scan_blocks(
+        &mut self,
+        start: Height,
+        end: Height,
+        dust_limit: Amount,
+        with_cutthrough: bool,
+    ) -> Result<()>;
+
+    /// Process a single block's data
+    /// 
+    /// # Arguments
+    /// * `blockdata` - Block data containing tweaks and filters
+    /// 
+    /// # Returns
+    /// * `(found_outputs, found_inputs)` - Tuple of found outputs and spent inputs
+    async fn process_block(
+        &mut self,
+        blockdata: BlockData,
+    ) -> Result<(HashMap<OutPoint, OwnedOutput>, HashSet<OutPoint>)>;
+
+    /// Process block outputs to find owned silent payment outputs
+    /// 
+    /// # Arguments
+    /// * `blkheight` - Block height
+    /// * `tweaks` - List of tweak public keys
+    /// * `new_utxo_filter` - Filter data for new UTXOs
+    /// 
+    /// # Returns
+    /// * Map of outpoints to owned outputs
+    async fn process_block_outputs(
+        &self,
+        blkheight: Height,
+        tweaks: Vec<bitcoin::secp256k1::PublicKey>,
+        new_utxo_filter: FilterData,
+    ) -> Result<HashMap<OutPoint, OwnedOutput>>;
+
+    /// Process block inputs to find spent outputs
+    /// 
+    /// # Arguments
+    /// * `blkheight` - Block height
+    /// * `spent_filter` - Filter data for spent outputs
+    /// 
+    /// # Returns
+    /// * Set of spent outpoints
+    async fn process_block_inputs(
+        &self,
+        blkheight: Height,
+        spent_filter: FilterData,
+    ) -> Result<HashSet<OutPoint>>;
+
+    /// Get the block data stream for a range of blocks
+    /// 
+    /// # Arguments
+    /// * `range` - Range of block heights
+    /// * `dust_limit` - Minimum amount to consider
+    /// * `with_cutthrough` - Whether to use cutthrough optimization
+    /// 
+    /// # Returns
+    /// * Stream of block data results
+    fn get_block_data_stream(
+        &self,
+        range: std::ops::RangeInclusive<u32>,
+        dust_limit: Amount,
+        with_cutthrough: bool,
+    ) -> std::pin::Pin<Box<dyn Stream<Item = Result<BlockData>> + Send>>;
+
+    /// Check if scanning should be interrupted
+    /// 
+    /// # Returns
+    /// * `true` if scanning should stop, `false` otherwise
+    fn should_interrupt(&self) -> bool;
+
+    /// Save current state to persistent storage
+    fn save_state(&mut self) -> Result<()>;
+
+    /// Record found outputs for a block
+    /// 
+    /// # Arguments
+    /// * `height` - Block height
+    /// * `block_hash` - Block hash
+    /// * `outputs` - Found outputs
+    fn record_outputs(
+        &mut self,
+        height: Height,
+        block_hash: BlockHash,
+        outputs: HashMap<OutPoint, OwnedOutput>,
+    ) -> Result<()>;
+
+    /// Record spent inputs for a block
+    /// 
+    /// # Arguments
+    /// * `height` - Block height
+    /// * `block_hash` - Block hash
+    /// * `inputs` - Spent inputs
+    fn record_inputs(
+        &mut self,
+        height: Height,
+        block_hash: BlockHash,
+        inputs: HashSet<OutPoint>,
+    ) -> Result<()>;
+
+    /// Record scan progress
+    /// 
+    /// # Arguments
+    /// * `start` - Start height
+    /// * `current` - Current height
+    /// * `end` - End height
+    fn record_progress(&mut self, start: Height, current: Height, end: Height) -> Result<()>;
+
+    /// Get the silent payment client
+    fn client(&self) -> &SpClient;
+
+    /// Get the chain backend
+    fn backend(&self) -> &dyn ChainBackend;
+
+    /// Get the updater
+    fn updater(&mut self) -> &mut dyn Updater;
+
+    // Helper methods with default implementations
+
+    /// Process multiple blocks from a stream
+    /// 
+    /// This is a default implementation that can be overridden if needed
+    async fn process_blocks(
+        &mut self,
+        start: Height,
+        end: Height,
+        block_data_stream: impl Stream<Item = Result<BlockData>> + Unpin + Send,
+    ) -> Result<()> {
+        use futures::StreamExt;
+        use std::time::{Duration, Instant};
+
+        let mut update_time = Instant::now();
+        let mut stream = block_data_stream;
+
+        while let Some(blockdata) = stream.next().await {
+            let blockdata = blockdata?;
+            let blkheight = blockdata.blkheight;
+            let blkhash = blockdata.blkhash;
+
+            // stop scanning and return if interrupted
+            if self.should_interrupt() {
+                self.save_state()?;
+                return Ok(());
+            }
+
+            let mut save_to_storage = false;
+
+            // always save on last block or after 30 seconds since last save
+            if blkheight == end || update_time.elapsed() > Duration::from_secs(30) {
+                save_to_storage = true;
+            }
+
+            let (found_outputs, found_inputs) = self.process_block(blockdata).await?;
+
+            if !found_outputs.is_empty() {
+                save_to_storage = true;
+                self.record_outputs(blkheight, blkhash, found_outputs)?;
+            }
+
+            if !found_inputs.is_empty() {
+                save_to_storage = true;
+                self.record_inputs(blkheight, blkhash, found_inputs)?;
+            }
+
+            // tell the updater we scanned this block
+            self.record_progress(start, blkheight, end)?;
+
+            if save_to_storage {
+                self.save_state()?;
+                update_time = Instant::now();
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Scan UTXOs for a given block and secrets map
+    /// 
+    /// This is a default implementation that can be overridden if needed
+    async fn scan_utxos(
+        &self,
+        blkheight: Height,
+        secrets_map: HashMap<[u8; 34], bitcoin::secp256k1::PublicKey>,
+    ) -> Result<Vec<(Option<Label>, UtxoData, bitcoin::secp256k1::Scalar)>> {
+        let utxos = self.backend().utxos(blkheight).await?;
+
+        let mut res: Vec<(Option<Label>, UtxoData, bitcoin::secp256k1::Scalar)> = vec![];
+
+        // group utxos by the txid
+        let mut txmap: HashMap<Txid, Vec<UtxoData>> = HashMap::new();
+        for utxo in utxos {
+            txmap.entry(utxo.txid).or_default().push(utxo);
+        }
+
+        for utxos in txmap.into_values() {
+            // check if we know the secret to any of the spks
+            let mut secret = None;
+            for utxo in utxos.iter() {
+                let spk = utxo.scriptpubkey.as_bytes();
+                if let Some(s) = secrets_map.get(spk) {
+                    secret = Some(s);
+                    break;
+                }
+            }
+
+            // skip this tx if no secret is found
+            let secret = match secret {
+                Some(secret) => secret,
+                None => continue,
+            };
+
+            let output_keys: Result<Vec<XOnlyPublicKey>> = utxos
+                .iter()
+                .filter_map(|x| {
+                    if x.scriptpubkey.is_p2tr() {
+                        Some(
+                            XOnlyPublicKey::from_slice(&x.scriptpubkey.as_bytes()[2..])
+                                .map_err(Error::new),
+                        )
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            let ours = self
+                .client()
+                .sp_receiver
+                .scan_transaction(secret, output_keys?)?;
+
+            for utxo in utxos {
+                if !utxo.scriptpubkey.is_p2tr() || utxo.spent {
+                    continue;
+                }
+
+                match XOnlyPublicKey::from_slice(&utxo.scriptpubkey.as_bytes()[2..]) {
+                    Ok(xonly) => {
+                        for (label, map) in ours.iter() {
+                            if let Some(scalar) = map.get(&xonly) {
+                                res.push((label.clone(), utxo, *scalar));
+                                break;
+                            }
+                        }
+                    }
+                    Err(_) => todo!(),
+                }
+            }
+        }
+
+        Ok(res)
+    }
+
+    /// Check if block contains relevant output transactions
+    /// 
+    /// This is a default implementation that can be overridden if needed
+    fn check_block_outputs(
+        created_utxo_filter: BlockFilter,
+        blkhash: BlockHash,
+        candidate_spks: Vec<&[u8; 34]>,
+    ) -> Result<bool> {
+        // check output scripts
+        let output_keys: Vec<_> = candidate_spks
+            .into_iter()
+            .map(|spk| spk[2..].as_ref())
+            .collect();
+
+        // note: match will always return true for an empty query!
+        if !output_keys.is_empty() {
+            Ok(created_utxo_filter.match_any(&blkhash, &mut output_keys.into_iter())?)
+        } else {
+            Ok(false)
+        }
+    }
+
+    /// Get input hashes for owned outpoints
+    /// 
+    /// This is a default implementation that can be overridden if needed
+    fn get_input_hashes(&self, blkhash: BlockHash) -> Result<HashMap<[u8; 8], OutPoint>>;
+
+    /// Check if block contains relevant input transactions
+    /// 
+    /// This is a default implementation that can be overridden if needed
+    fn check_block_inputs(
+        &self,
+        spent_filter: BlockFilter,
+        blkhash: BlockHash,
+        input_hashes: Vec<[u8; 8]>,
+    ) -> Result<bool> {
+        // note: match will always return true for an empty query!
+        if !input_hashes.is_empty() {
+            Ok(spent_filter.match_any(&blkhash, &mut input_hashes.into_iter())?)
+        } else {
+            Ok(false)
+        }
+    }
+}

From 878228f6ddbc7e1642e1f5a9dd80080db2dc58d3 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Fri, 22 Aug 2025 10:16:03 +0200
Subject: [PATCH 11/18] Update test-compilation and readme

---
 backend-blindbit-wasm/README.md | 70 +++++++++++++++++++++++++++++++++
 test-compilation.sh             | 29 ++++++++------
 2 files changed, 87 insertions(+), 12 deletions(-)
 create mode 100644 backend-blindbit-wasm/README.md

diff --git a/backend-blindbit-wasm/README.md b/backend-blindbit-wasm/README.md
new file mode 100644
index 0000000..723a22f
--- /dev/null
+++ b/backend-blindbit-wasm/README.md
@@ -0,0 +1,70 @@
+# Backend Blindbit WASM
+
+**⚠️ This crate is designed exclusively for WebAssembly targets.**
+
+## Building
+
+This crate must be compiled with the `wasm32-unknown-unknown` target:
+
+```bash
+# Check compilation
+cargo check -p backend-blindbit-wasm --target wasm32-unknown-unknown
+
+# Build for production
+cargo build -p backend-blindbit-wasm --target wasm32-unknown-unknown --release
+```
+
+## IDE Integration
+
+### Rust Analyzer Errors
+
+If you see errors in rust-analyzer like "unresolved import" or "could not resolve", this is normal. 
+Rust-analyzer runs with the default target (usually your native platform), but this crate is WASM-only.
+
+**Solutions:**
+
+1. **Ignore the errors** - they won't appear when building with the correct target
+2. **Configure your IDE** to use WASM target for this specific crate
+3. **Use the test script** to verify everything compiles correctly:
+   ```bash
+   ./test-compilation.sh
+   ```
+
+### VSCode Setup
+
+The workspace includes `.vscode/settings.json` with rust-analyzer configuration that should help reduce false errors.
+
+## How It Works
+
+This crate uses `reqwest` for HTTP requests. When compiled to WASM:
+
+- `reqwest` automatically detects the WASM target
+- Instead of native networking, it generates bindings to the browser's `fetch()` API
+- Your Rust code stays the same, but the implementation completely changes under the hood
+
+```rust
+// This Rust code:
+let response = reqwest::get("https://api.example.com").await?;
+
+// Becomes this JavaScript when compiled to WASM:
+// fetch("https://api.example.com").then(...)
+```
+
+## Limitations
+
+When running in WASM:
+- No custom timeouts (browser manages this)
+- Limited TLS configuration (browser handles TLS)
+- Cookies managed by browser
+- CORS restrictions apply
+
+## Usage
+
+```rust
+use backend_blindbit_wasm::BlindbitClient;
+
+// Same API as native version
+let client = BlindbitClient::new("https://blindbit-api.com".to_string())?;
+let height = client.block_height().await?;
+```
+
diff --git a/test-compilation.sh b/test-compilation.sh
index 242aa29..c543fc4 100755
--- a/test-compilation.sh
+++ b/test-compilation.sh
@@ -6,12 +6,12 @@ echo "🧪 Testing All Compilation Scenarios"
 echo "===================================="
 
 echo ""
-echo "✅ 1. Testing workspace with all features..."
-cargo check --workspace --all-features
+echo "✅ 1. Testing workspace with all features (excluding WASM backend)..."
+cargo check --workspace --exclude backend-blindbit-wasm --all-features
 
 echo ""
-echo "✅ 2. Testing workspace with no features..."
-cargo check --workspace --no-default-features
+echo "✅ 2. Testing workspace with no features (excluding WASM backend)..."
+cargo check --workspace --exclude backend-blindbit-wasm --no-default-features
 
 echo ""
 echo "✅ 3. Testing core client only (default)..."
@@ -38,17 +38,21 @@ echo "✅ 8. Testing core client for WASM (with no features)..."
 cargo check -p sp-client --target wasm32-unknown-unknown --no-default-features
 
 echo ""
-echo "❌ 9. Testing that backend FAILS for WASM (expected to fail)..."
+echo "✅ 9. Testing WASM backend for WASM target..."
+cargo check -p backend-blindbit-wasm --target wasm32-unknown-unknown
+
+echo ""
+echo "❌ 10. Testing that native backend FAILS for WASM (expected to fail)..."
 if cargo check -p backend-blindbit-native --target wasm32-unknown-unknown 2>/dev/null; then
-    echo "ERROR: Backend should NOT compile for WASM!"
+    echo "ERROR: Native backend should NOT compile for WASM!"
     exit 1
 else
-    echo "✅ Good! Backend correctly fails to compile for WASM"
+    echo "✅ Good! Native backend correctly fails to compile for WASM"
 fi
 
 echo ""
-echo "✅ 10. Testing build (not just check)..."
-cargo build --workspace --all-features
+echo "✅ 11. Testing build (not just check, excluding WASM backend)..."
+cargo build --workspace --exclude backend-blindbit-wasm --all-features
 
 echo ""
 echo "🎉 All compilation tests passed!"
@@ -57,6 +61,7 @@ echo "Summary:"
 echo "--------"
 echo "✅ Core client compiles for native and WASM"
 echo "✅ Core client works with and without features"
-echo "✅ Backend compiles for native only"
-echo "❌ Backend correctly fails for WASM"
-echo "✅ Workspace supports all feature combinations"
+echo "✅ Native backend compiles for native only"
+echo "✅ WASM backend compiles for WASM only"
+echo "❌ Native backend correctly fails for WASM"
+echo "✅ Workspace supports all feature combinations (with target-specific exclusions)"

From 224c740ac3f5977c9535dcc40dadf958069f1e9c Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Sat, 23 Aug 2025 13:14:24 +0200
Subject: [PATCH 12/18] Reexport wasm_bindgen_futures from wasm package

---
 backend-blindbit-wasm/src/lib.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/backend-blindbit-wasm/src/lib.rs b/backend-blindbit-wasm/src/lib.rs
index c0c24fc..7a08415 100644
--- a/backend-blindbit-wasm/src/lib.rs
+++ b/backend-blindbit-wasm/src/lib.rs
@@ -30,5 +30,6 @@ mod scanner;
 pub use backend::{ChainBackend, BlindbitBackend, BlindbitClient};
 pub use scanner::SpScanner;
 
-// Re-export core client for convenience (includes Updater)
-pub use sp_client::*;
+use sp_client::*;
+
+pub use wasm_bindgen_futures;

From b1710e7d16592e52a2a77618ceb4d56d5d51db8e Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Sat, 23 Aug 2025 14:26:03 +0200
Subject: [PATCH 13/18] Fix SpScanner in both native and wasm

---
 backend-blindbit-native/src/scanner/mod.rs | 3 +--
 backend-blindbit-wasm/src/scanner/mod.rs   | 7 +++----
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/backend-blindbit-native/src/scanner/mod.rs b/backend-blindbit-native/src/scanner/mod.rs
index 3bd611d..72c76eb 100644
--- a/backend-blindbit-native/src/scanner/mod.rs
+++ b/backend-blindbit-native/src/scanner/mod.rs
@@ -20,8 +20,7 @@ use crate::backend::ChainBackend;
 /// 
 /// This trait abstracts the core scanning functionality, allowing consumers
 /// to implement it with their own constraints and requirements.
-#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
+#[async_trait::async_trait]
 pub trait SpScanner {
     /// Scan a range of blocks for silent payment outputs and inputs
     /// 
diff --git a/backend-blindbit-wasm/src/scanner/mod.rs b/backend-blindbit-wasm/src/scanner/mod.rs
index 3bd611d..2e23064 100644
--- a/backend-blindbit-wasm/src/scanner/mod.rs
+++ b/backend-blindbit-wasm/src/scanner/mod.rs
@@ -20,8 +20,7 @@ use crate::backend::ChainBackend;
 /// 
 /// This trait abstracts the core scanning functionality, allowing consumers
 /// to implement it with their own constraints and requirements.
-#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
+#[async_trait::async_trait(?Send)]
 pub trait SpScanner {
     /// Scan a range of blocks for silent payment outputs and inputs
     /// 
@@ -94,7 +93,7 @@ pub trait SpScanner {
         range: std::ops::RangeInclusive<u32>,
         dust_limit: Amount,
         with_cutthrough: bool,
-    ) -> std::pin::Pin<Box<dyn Stream<Item = Result<BlockData>> + Send>>;
+    ) -> std::pin::Pin<Box<dyn Stream<Item = Result<BlockData>>>>;
 
     /// Check if scanning should be interrupted
     /// 
@@ -157,7 +156,7 @@ pub trait SpScanner {
         &mut self,
         start: Height,
         end: Height,
-        block_data_stream: impl Stream<Item = Result<BlockData>> + Unpin + Send,
+        block_data_stream: impl Stream<Item = Result<BlockData>> + Unpin,
     ) -> Result<()> {
         use futures::StreamExt;
         use std::time::{Duration, Instant};

From b4db6bb993d8c237fb41cd4e04b96f9e5acdb641 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Wed, 17 Sep 2025 17:32:34 +0200
Subject: [PATCH 14/18] cargo fmt

---
 backend-blindbit-native/src/lib.rs            |  2 +-
 backend-blindbit-native/src/scanner/mod.rs    | 45 +++++++++----------
 .../src/backend/blindbit/client/client.rs     |  8 +---
 backend-blindbit-wasm/src/lib.rs              | 22 ++++-----
 backend-blindbit-wasm/src/scanner/mod.rs      | 45 +++++++++----------
 sp-client/src/client/client.rs                |  2 +-
 6 files changed, 57 insertions(+), 67 deletions(-)

diff --git a/backend-blindbit-native/src/lib.rs b/backend-blindbit-native/src/lib.rs
index 00bc7a7..bd82bd9 100644
--- a/backend-blindbit-native/src/lib.rs
+++ b/backend-blindbit-native/src/lib.rs
@@ -2,7 +2,7 @@ mod backend;
 mod scanner;
 
 // Re-export backend functionality
-pub use backend::{ChainBackend, BlindbitBackend, BlindbitClient};
+pub use backend::{BlindbitBackend, BlindbitClient, ChainBackend};
 pub use scanner::SpScanner;
 
 // Re-export core client for convenience (includes Updater)
diff --git a/backend-blindbit-native/src/scanner/mod.rs b/backend-blindbit-native/src/scanner/mod.rs
index 72c76eb..9716f73 100644
--- a/backend-blindbit-native/src/scanner/mod.rs
+++ b/backend-blindbit-native/src/scanner/mod.rs
@@ -2,28 +2,25 @@ use std::collections::{HashMap, HashSet};
 
 use anyhow::{Error, Result};
 use bitcoin::{
-    absolute::Height, bip158::BlockFilter, 
-    Amount, BlockHash, OutPoint, Txid, XOnlyPublicKey
+    absolute::Height, bip158::BlockFilter, Amount, BlockHash, OutPoint, Txid, XOnlyPublicKey,
 };
 use futures::Stream;
 use silentpayments::receiving::Label;
 
 // Updater now comes from sp-client
 
-use sp_client::{
-    BlockData, FilterData, UtxoData, OwnedOutput, SpClient, Updater,
-};
+use sp_client::{BlockData, FilterData, OwnedOutput, SpClient, Updater, UtxoData};
 
 use crate::backend::ChainBackend;
 
 /// Trait for scanning silent payment blocks
-/// 
+///
 /// This trait abstracts the core scanning functionality, allowing consumers
 /// to implement it with their own constraints and requirements.
 #[async_trait::async_trait]
 pub trait SpScanner {
     /// Scan a range of blocks for silent payment outputs and inputs
-    /// 
+    ///
     /// # Arguments
     /// * `start` - Starting block height (inclusive)
     /// * `end` - Ending block height (inclusive)
@@ -38,10 +35,10 @@ pub trait SpScanner {
     ) -> Result<()>;
 
     /// Process a single block's data
-    /// 
+    ///
     /// # Arguments
     /// * `blockdata` - Block data containing tweaks and filters
-    /// 
+    ///
     /// # Returns
     /// * `(found_outputs, found_inputs)` - Tuple of found outputs and spent inputs
     async fn process_block(
@@ -50,12 +47,12 @@ pub trait SpScanner {
     ) -> Result<(HashMap<OutPoint, OwnedOutput>, HashSet<OutPoint>)>;
 
     /// Process block outputs to find owned silent payment outputs
-    /// 
+    ///
     /// # Arguments
     /// * `blkheight` - Block height
     /// * `tweaks` - List of tweak public keys
     /// * `new_utxo_filter` - Filter data for new UTXOs
-    /// 
+    ///
     /// # Returns
     /// * Map of outpoints to owned outputs
     async fn process_block_outputs(
@@ -66,11 +63,11 @@ pub trait SpScanner {
     ) -> Result<HashMap<OutPoint, OwnedOutput>>;
 
     /// Process block inputs to find spent outputs
-    /// 
+    ///
     /// # Arguments
     /// * `blkheight` - Block height
     /// * `spent_filter` - Filter data for spent outputs
-    /// 
+    ///
     /// # Returns
     /// * Set of spent outpoints
     async fn process_block_inputs(
@@ -80,12 +77,12 @@ pub trait SpScanner {
     ) -> Result<HashSet<OutPoint>>;
 
     /// Get the block data stream for a range of blocks
-    /// 
+    ///
     /// # Arguments
     /// * `range` - Range of block heights
     /// * `dust_limit` - Minimum amount to consider
     /// * `with_cutthrough` - Whether to use cutthrough optimization
-    /// 
+    ///
     /// # Returns
     /// * Stream of block data results
     fn get_block_data_stream(
@@ -96,7 +93,7 @@ pub trait SpScanner {
     ) -> std::pin::Pin<Box<dyn Stream<Item = Result<BlockData>> + Send>>;
 
     /// Check if scanning should be interrupted
-    /// 
+    ///
     /// # Returns
     /// * `true` if scanning should stop, `false` otherwise
     fn should_interrupt(&self) -> bool;
@@ -105,7 +102,7 @@ pub trait SpScanner {
     fn save_state(&mut self) -> Result<()>;
 
     /// Record found outputs for a block
-    /// 
+    ///
     /// # Arguments
     /// * `height` - Block height
     /// * `block_hash` - Block hash
@@ -118,7 +115,7 @@ pub trait SpScanner {
     ) -> Result<()>;
 
     /// Record spent inputs for a block
-    /// 
+    ///
     /// # Arguments
     /// * `height` - Block height
     /// * `block_hash` - Block hash
@@ -131,7 +128,7 @@ pub trait SpScanner {
     ) -> Result<()>;
 
     /// Record scan progress
-    /// 
+    ///
     /// # Arguments
     /// * `start` - Start height
     /// * `current` - Current height
@@ -150,7 +147,7 @@ pub trait SpScanner {
     // Helper methods with default implementations
 
     /// Process multiple blocks from a stream
-    /// 
+    ///
     /// This is a default implementation that can be overridden if needed
     async fn process_blocks(
         &mut self,
@@ -207,7 +204,7 @@ pub trait SpScanner {
     }
 
     /// Scan UTXOs for a given block and secrets map
-    /// 
+    ///
     /// This is a default implementation that can be overridden if needed
     async fn scan_utxos(
         &self,
@@ -283,7 +280,7 @@ pub trait SpScanner {
     }
 
     /// Check if block contains relevant output transactions
-    /// 
+    ///
     /// This is a default implementation that can be overridden if needed
     fn check_block_outputs(
         created_utxo_filter: BlockFilter,
@@ -305,12 +302,12 @@ pub trait SpScanner {
     }
 
     /// Get input hashes for owned outpoints
-    /// 
+    ///
     /// This is a default implementation that can be overridden if needed
     fn get_input_hashes(&self, blkhash: BlockHash) -> Result<HashMap<[u8; 8], OutPoint>>;
 
     /// Check if block contains relevant input transactions
-    /// 
+    ///
     /// This is a default implementation that can be overridden if needed
     fn check_block_inputs(
         &self,
diff --git a/backend-blindbit-wasm/src/backend/blindbit/client/client.rs b/backend-blindbit-wasm/src/backend/blindbit/client/client.rs
index b42b5bd..ce4bb1b 100644
--- a/backend-blindbit-wasm/src/backend/blindbit/client/client.rs
+++ b/backend-blindbit-wasm/src/backend/blindbit/client/client.rs
@@ -1,6 +1,6 @@
+use anyhow::Result;
 use bitcoin::{absolute::Height, secp256k1::PublicKey, Amount, Txid};
 use reqwest::{Client, Url};
-use anyhow::Result;
 
 use crate::backend::blindbit::client::structs::InfoResponse;
 
@@ -30,11 +30,7 @@ impl BlindbitClient {
     pub async fn block_height(&self) -> Result<Height> {
         let url = self.host_url.join("block-height")?;
 
-        let res = self
-            .client
-            .get(url)
-            .send()
-            .await?;
+        let res = self.client.get(url).send().await?;
         let blkheight: BlockHeightResponse = serde_json::from_str(&res.text().await?)?;
         Ok(blkheight.block_height)
     }
diff --git a/backend-blindbit-wasm/src/lib.rs b/backend-blindbit-wasm/src/lib.rs
index 7a08415..4c62f57 100644
--- a/backend-blindbit-wasm/src/lib.rs
+++ b/backend-blindbit-wasm/src/lib.rs
@@ -1,33 +1,33 @@
 //! # Backend Blindbit WASM
-//! 
+//!
 //! **⚠️ WASM-only crate**: This crate is designed specifically for WebAssembly targets.
-//! 
+//!
 //! ## Build Requirements
-//! 
+//!
 //! This crate must be compiled with the `wasm32-unknown-unknown` target:
-//! 
+//!
 //! ```bash
 //! cargo build -p backend-blindbit-wasm --target wasm32-unknown-unknown
 //! ```
-//! 
+//!
 //! ## IDE Setup
-//! 
+//!
 //! If you see errors in rust-analyzer, it's because it's checking with the native target.
 //! To fix this, you can either:
-//! 
+//!
 //! 1. Set your IDE to use the WASM target for this crate
 //! 2. Or ignore the errors - they won't appear when building with the correct target
-//! 
+//!
 //! ## HTTP Client
-//! 
-//! This crate uses `reqwest` which automatically uses the browser's `fetch()` API when 
+//!
+//! This crate uses `reqwest` which automatically uses the browser's `fetch()` API when
 //! compiled to WebAssembly.
 
 mod backend;
 mod scanner;
 
 // Re-export backend functionality
-pub use backend::{ChainBackend, BlindbitBackend, BlindbitClient};
+pub use backend::{BlindbitBackend, BlindbitClient, ChainBackend};
 pub use scanner::SpScanner;
 
 use sp_client::*;
diff --git a/backend-blindbit-wasm/src/scanner/mod.rs b/backend-blindbit-wasm/src/scanner/mod.rs
index 2e23064..b68d57a 100644
--- a/backend-blindbit-wasm/src/scanner/mod.rs
+++ b/backend-blindbit-wasm/src/scanner/mod.rs
@@ -2,28 +2,25 @@ use std::collections::{HashMap, HashSet};
 
 use anyhow::{Error, Result};
 use bitcoin::{
-    absolute::Height, bip158::BlockFilter, 
-    Amount, BlockHash, OutPoint, Txid, XOnlyPublicKey
+    absolute::Height, bip158::BlockFilter, Amount, BlockHash, OutPoint, Txid, XOnlyPublicKey,
 };
 use futures::Stream;
 use silentpayments::receiving::Label;
 
 // Updater now comes from sp-client
 
-use sp_client::{
-    BlockData, FilterData, UtxoData, OwnedOutput, SpClient, Updater,
-};
+use sp_client::{BlockData, FilterData, OwnedOutput, SpClient, Updater, UtxoData};
 
 use crate::backend::ChainBackend;
 
 /// Trait for scanning silent payment blocks
-/// 
+///
 /// This trait abstracts the core scanning functionality, allowing consumers
 /// to implement it with their own constraints and requirements.
 #[async_trait::async_trait(?Send)]
 pub trait SpScanner {
     /// Scan a range of blocks for silent payment outputs and inputs
-    /// 
+    ///
     /// # Arguments
     /// * `start` - Starting block height (inclusive)
     /// * `end` - Ending block height (inclusive)
@@ -38,10 +35,10 @@ pub trait SpScanner {
     ) -> Result<()>;
 
     /// Process a single block's data
-    /// 
+    ///
     /// # Arguments
     /// * `blockdata` - Block data containing tweaks and filters
-    /// 
+    ///
     /// # Returns
     /// * `(found_outputs, found_inputs)` - Tuple of found outputs and spent inputs
     async fn process_block(
@@ -50,12 +47,12 @@ pub trait SpScanner {
     ) -> Result<(HashMap<OutPoint, OwnedOutput>, HashSet<OutPoint>)>;
 
     /// Process block outputs to find owned silent payment outputs
-    /// 
+    ///
     /// # Arguments
     /// * `blkheight` - Block height
     /// * `tweaks` - List of tweak public keys
     /// * `new_utxo_filter` - Filter data for new UTXOs
-    /// 
+    ///
     /// # Returns
     /// * Map of outpoints to owned outputs
     async fn process_block_outputs(
@@ -66,11 +63,11 @@ pub trait SpScanner {
     ) -> Result<HashMap<OutPoint, OwnedOutput>>;
 
     /// Process block inputs to find spent outputs
-    /// 
+    ///
     /// # Arguments
     /// * `blkheight` - Block height
     /// * `spent_filter` - Filter data for spent outputs
-    /// 
+    ///
     /// # Returns
     /// * Set of spent outpoints
     async fn process_block_inputs(
@@ -80,12 +77,12 @@ pub trait SpScanner {
     ) -> Result<HashSet<OutPoint>>;
 
     /// Get the block data stream for a range of blocks
-    /// 
+    ///
     /// # Arguments
     /// * `range` - Range of block heights
     /// * `dust_limit` - Minimum amount to consider
     /// * `with_cutthrough` - Whether to use cutthrough optimization
-    /// 
+    ///
     /// # Returns
     /// * Stream of block data results
     fn get_block_data_stream(
@@ -96,7 +93,7 @@ pub trait SpScanner {
     ) -> std::pin::Pin<Box<dyn Stream<Item = Result<BlockData>>>>;
 
     /// Check if scanning should be interrupted
-    /// 
+    ///
     /// # Returns
     /// * `true` if scanning should stop, `false` otherwise
     fn should_interrupt(&self) -> bool;
@@ -105,7 +102,7 @@ pub trait SpScanner {
     fn save_state(&mut self) -> Result<()>;
 
     /// Record found outputs for a block
-    /// 
+    ///
     /// # Arguments
     /// * `height` - Block height
     /// * `block_hash` - Block hash
@@ -118,7 +115,7 @@ pub trait SpScanner {
     ) -> Result<()>;
 
     /// Record spent inputs for a block
-    /// 
+    ///
     /// # Arguments
     /// * `height` - Block height
     /// * `block_hash` - Block hash
@@ -131,7 +128,7 @@ pub trait SpScanner {
     ) -> Result<()>;
 
     /// Record scan progress
-    /// 
+    ///
     /// # Arguments
     /// * `start` - Start height
     /// * `current` - Current height
@@ -150,7 +147,7 @@ pub trait SpScanner {
     // Helper methods with default implementations
 
     /// Process multiple blocks from a stream
-    /// 
+    ///
     /// This is a default implementation that can be overridden if needed
     async fn process_blocks(
         &mut self,
@@ -207,7 +204,7 @@ pub trait SpScanner {
     }
 
     /// Scan UTXOs for a given block and secrets map
-    /// 
+    ///
     /// This is a default implementation that can be overridden if needed
     async fn scan_utxos(
         &self,
@@ -283,7 +280,7 @@ pub trait SpScanner {
     }
 
     /// Check if block contains relevant output transactions
-    /// 
+    ///
     /// This is a default implementation that can be overridden if needed
     fn check_block_outputs(
         created_utxo_filter: BlockFilter,
@@ -305,12 +302,12 @@ pub trait SpScanner {
     }
 
     /// Get input hashes for owned outpoints
-    /// 
+    ///
     /// This is a default implementation that can be overridden if needed
     fn get_input_hashes(&self, blkhash: BlockHash) -> Result<HashMap<[u8; 8], OutPoint>>;
 
     /// Check if block contains relevant input transactions
-    /// 
+    ///
     /// This is a default implementation that can be overridden if needed
     fn check_block_inputs(
         &self,
diff --git a/sp-client/src/client/client.rs b/sp-client/src/client/client.rs
index 11c715c..8466dbf 100644
--- a/sp-client/src/client/client.rs
+++ b/sp-client/src/client/client.rs
@@ -8,9 +8,9 @@ use bitcoin::{
 };
 use serde::{Deserialize, Serialize};
 
-use std::collections::HashMap;
 use bitcoin::secp256k1::PublicKey;
 use silentpayments::utils as sp_utils;
+use std::collections::HashMap;
 
 use silentpayments::Network as SpNetwork;
 use silentpayments::{

From 3d32e8b4816e22ae344ccb2333d37a7c36635635 Mon Sep 17 00:00:00 2001
From: pythcoiner <pythcoiner@proton.me>
Date: Sun, 26 Oct 2025 07:26:03 +0100
Subject: [PATCH 15/18] repo: clippyfy

---
 backend-blindbit-native/src/lib.rs |  1 +
 backend-blindbit-wasm/src/lib.rs   |  2 ++
 sp-client/src/client/spend.rs      | 11 +++++------
 sp-client/src/client/structs.rs    |  3 ++-
 sp-client/src/lib.rs               |  2 ++
 5 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/backend-blindbit-native/src/lib.rs b/backend-blindbit-native/src/lib.rs
index bd82bd9..98a8fc0 100644
--- a/backend-blindbit-native/src/lib.rs
+++ b/backend-blindbit-native/src/lib.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::module_inception)]
 mod backend;
 mod scanner;
 
diff --git a/backend-blindbit-wasm/src/lib.rs b/backend-blindbit-wasm/src/lib.rs
index 4c62f57..394753a 100644
--- a/backend-blindbit-wasm/src/lib.rs
+++ b/backend-blindbit-wasm/src/lib.rs
@@ -23,6 +23,8 @@
 //! This crate uses `reqwest` which automatically uses the browser's `fetch()` API when
 //! compiled to WebAssembly.
 
+#![allow(clippy::module_inception)]
+
 mod backend;
 mod scanner;
 
diff --git a/sp-client/src/client/spend.rs b/sp-client/src/client/spend.rs
index bb14afe..240b5f9 100644
--- a/sp-client/src/client/spend.rs
+++ b/sp-client/src/client/spend.rs
@@ -41,7 +41,7 @@ impl SpClient {
             .iter()
             .any(|(_, o)| o.spend_status != OutputSpendStatus::Unspent)
         {
-            return Err(Error::msg(format!("All outputs must be unspent")));
+            return Err(Error::msg("All outputs must be unspent".to_string()));
         }
 
         // used to estimate the size of a taproot output
@@ -98,7 +98,7 @@ impl SpClient {
                         )))
                     } else {
                         let mut op_return = PushBytesBuf::with_capacity(data_len);
-                        op_return.extend_from_slice(&data)?;
+                        op_return.extend_from_slice(data)?;
                         let script_pubkey = ScriptBuf::new_op_return(op_return);
 
                         Ok(TxOut {
@@ -145,8 +145,7 @@ impl SpClient {
         let change = coin_selector.drain(target, change_policy);
         let change_value = if change.is_some() { change.value } else { 0 };
         if change_value > 0 {
-            let change_address =
-                SilentPaymentAddress::try_from(self.sp_receiver.get_change_address())?;
+            let change_address = self.sp_receiver.get_change_address();
             recipients.push(Recipient {
                 address: RecipientAddress::SpAddress(change_address),
                 amount: Amount::from_sat(change_value),
@@ -177,7 +176,7 @@ impl SpClient {
             .iter()
             .any(|(_, o)| o.spend_status != OutputSpendStatus::Unspent)
         {
-            return Err(Error::msg(format!("All outputs must be unspent")));
+            return Err(Error::msg("All outputs must be unspent".to_string()));
         }
 
         // used to estimate the size of a taproot output
@@ -345,7 +344,7 @@ impl SpClient {
                         )));
                     }
                     let mut op_return = PushBytesBuf::with_capacity(data_len);
-                    op_return.extend_from_slice(&data)?;
+                    op_return.extend_from_slice(data)?;
                     let script = ScriptBuf::new_op_return(op_return);
                     Ok(TxOut {
                         value: recipient.amount,
diff --git a/sp-client/src/client/structs.rs b/sp-client/src/client/structs.rs
index d3718cb..6812d9e 100644
--- a/sp-client/src/client/structs.rs
+++ b/sp-client/src/client/structs.rs
@@ -44,7 +44,7 @@ impl TryFrom<String> for RecipientAddress {
     type Error = anyhow::Error;
     fn try_from(value: String) -> Result<Self, Self::Error> {
         if let Ok(sp_address) = SilentPaymentAddress::try_from(value.as_str()) {
-            Ok(Self::SpAddress(sp_address.into()))
+            Ok(Self::SpAddress(sp_address))
         } else if let Ok(legacy_address) = Address::from_str(&value) {
             Ok(Self::LegacyAddress(legacy_address))
         } else if let Ok(data) = Vec::from_hex(&value) {
@@ -110,6 +110,7 @@ impl From<&SpendKey> for PublicKey {
 }
 
 impl From<SpendKey> for PublicKey {
+    #[allow(clippy::unconditional_recursion)]
     fn from(value: SpendKey) -> Self {
         value.into()
     }
diff --git a/sp-client/src/lib.rs b/sp-client/src/lib.rs
index 457bca5..7e05259 100644
--- a/sp-client/src/lib.rs
+++ b/sp-client/src/lib.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::module_inception)]
+
 pub mod client;
 pub mod constants;
 pub mod types;

From 89c0ec20e2e13a5c637e7448c68966cf8fe2188b Mon Sep 17 00:00:00 2001
From: pythcoiner <pythcoiner@proton.me>
Date: Sun, 26 Oct 2025 11:10:42 +0100
Subject: [PATCH 16/18] sp_client: impl From<SecretKey> for SpendKey

---
 sp-client/src/client/structs.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/sp-client/src/client/structs.rs b/sp-client/src/client/structs.rs
index 6812d9e..d0ae745 100644
--- a/sp-client/src/client/structs.rs
+++ b/sp-client/src/client/structs.rs
@@ -87,6 +87,12 @@ pub enum SpendKey {
     Public(PublicKey),
 }
 
+impl From<SecretKey> for SpendKey {
+    fn from(value: SecretKey) -> Self {
+        Self::Secret(value)
+    }
+}
+
 impl TryInto<SecretKey> for SpendKey {
     type Error = anyhow::Error;
     fn try_into(self) -> std::prelude::v1::Result<SecretKey, Error> {

From 87ecfeeb60c3685f3bb6e6db6190abc8faa4aa1f Mon Sep 17 00:00:00 2001
From: pythcoiner <pythcoiner@proton.me>
Date: Sun, 26 Oct 2025 11:19:44 +0100
Subject: [PATCH 17/18] sp_client: allow SpClient::default() only for tests

---
 sp-client/src/client/client.rs | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/sp-client/src/client/client.rs b/sp-client/src/client/client.rs
index 8466dbf..7724827 100644
--- a/sp-client/src/client/client.rs
+++ b/sp-client/src/client/client.rs
@@ -1,10 +1,9 @@
-use std::{io::Write, str::FromStr};
+use std::io::Write;
 
 use bitcoin::hashes::Hash;
 use bitcoin::{
-    key::constants::ONE,
-    secp256k1::{Scalar, Secp256k1, SecretKey},
-    Network, XOnlyPublicKey,
+    secp256k1::{Secp256k1, SecretKey},
+    Network,
 };
 use serde::{Deserialize, Serialize};
 
@@ -21,7 +20,15 @@ use silentpayments::{
 
 use anyhow::{Error, Result};
 
-use crate::constants::NUMS;
+#[cfg(test)]
+use {
+    crate::constants::NUMS,
+    bitcoin::{
+        key::constants::ONE,
+        secp256k1::{Scalar, XOnlyPublicKey},
+    },
+    std::str::FromStr,
+};
 
 use super::SpendKey;
 
@@ -33,6 +40,7 @@ pub struct SpClient {
     network: Network,
 }
 
+#[cfg(test)]
 impl Default for SpClient {
     fn default() -> Self {
         let default_sk = SecretKey::from_slice(&[0xcd; 32]).unwrap();

From 311188993422381293d9b60bfca32cb2c485cc78 Mon Sep 17 00:00:00 2001
From: pythcoiner <pythcoiner@proton.me>
Date: Sun, 26 Oct 2025 12:48:11 +0100
Subject: [PATCH 18/18] sp_client: add SpClient constructor from Mnemonic

---
 Cargo.toml                     |  1 +
 sp-client/Cargo.toml           |  6 ++-
 sp-client/src/client/client.rs | 78 +++++++++++++++++++++++++++++++++-
 sp-client/src/lib.rs           |  2 +
 4 files changed, 84 insertions(+), 3 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 27b099c..90f6375 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,6 +13,7 @@ anyhow = "1.0"
 serde = { version = "1.0.188", features = ["derive"] }
 serde_json = "1.0.107"
 bitcoin = { version = "0.31.1", features = ["serde", "rand", "base64"] }
+bip39 = { version = "2.2.0" }
 futures = "0.3"
 log = "0.4"
 async-trait = "0.1"
diff --git a/sp-client/Cargo.toml b/sp-client/Cargo.toml
index 5aa350c..c7cd167 100644
--- a/sp-client/Cargo.toml
+++ b/sp-client/Cargo.toml
@@ -20,6 +20,10 @@ bdk_coin_select.workspace = true
 # Optional for performance optimization
 rayon = { workspace = true, optional = true }
 
+# Optional for use bip39 mnemonics
+bip39 = { workspace = true, optional = true }
+
 [features]
-default = []
+default = ["mnemonic"]
+mnemonic = ["dep:bip39"] # Enable using bip39 mnemonics for create SpClient
 parallel = ["rayon"]  # Enable parallel processing for better performance
diff --git a/sp-client/src/client/client.rs b/sp-client/src/client/client.rs
index 7724827..5fc2d8b 100644
--- a/sp-client/src/client/client.rs
+++ b/sp-client/src/client/client.rs
@@ -7,7 +7,7 @@ use bitcoin::{
 };
 use serde::{Deserialize, Serialize};
 
-use bitcoin::secp256k1::PublicKey;
+use bitcoin::secp256k1::{All, PublicKey};
 use silentpayments::utils as sp_utils;
 use std::collections::HashMap;
 
@@ -30,6 +30,9 @@ use {
     std::str::FromStr,
 };
 
+#[cfg(feature = "mnemonic")]
+use bitcoin::bip32;
+
 use super::SpendKey;
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
@@ -65,7 +68,15 @@ impl Default for SpClient {
 
 impl SpClient {
     pub fn new(scan_sk: SecretKey, spend_key: SpendKey, network: Network) -> Result<Self> {
-        let secp = Secp256k1::signing_only();
+        let secp = Secp256k1::new();
+        Self::new_inner(scan_sk, spend_key, network, secp)
+    }
+    fn new_inner(
+        scan_sk: SecretKey,
+        spend_key: SpendKey,
+        network: Network,
+        secp: Secp256k1<All>,
+    ) -> Result<Self> {
         let scan_pubkey = scan_sk.public_key(&secp);
         let change_label = Label::new(scan_sk, 0);
 
@@ -81,6 +92,69 @@ impl SpClient {
             scan_pubkey,
             (&spend_key).into(),
             change_label,
+    #[cfg(feature = "mnemonic")]
+    pub fn new_from_mnemonic(mnemonic: bip39::Mnemonic, network: Network) -> Result<Self> {
+        use bitcoin::bip32::ChildNumber;
+
+        Self::new_from_mnemonic_with_passphrase_and_account(
+            mnemonic,
+            "",
+            network,
+            ChildNumber::from_hardened_idx(0).expect("zero"),
+        )
+    }
+
+    #[cfg(feature = "mnemonic")]
+    pub fn new_from_mnemonic_with_account(
+        mnemonic: bip39::Mnemonic,
+        network: Network,
+        account: bip32::ChildNumber,
+    ) -> Result<Self> {
+        Self::new_from_mnemonic_with_passphrase_and_account(mnemonic, "", network, account)
+    }
+
+    #[cfg(feature = "mnemonic")]
+    pub fn new_from_mnemonic_with_passphrase_and_account(
+        mnemonic: bip39::Mnemonic,
+        pp: &str,
+        network: Network,
+        account: bip32::ChildNumber,
+    ) -> Result<Self> {
+        let secp = Secp256k1::new();
+        let seed = mnemonic.to_seed(pp);
+        let master_xpriv = bip32::Xpriv::new_master(network, &seed)
+            .map_err(|_| Error::msg("Fails to generate Xpriv from seed"))?;
+        let network_idx = match network {
+            Network::Bitcoin => 0u32,
+            _ => 1,
+        };
+        let base_deriv = vec![
+            bip32::ChildNumber::from_hardened_idx(352).expect("352"),
+            bip32::ChildNumber::from_hardened_idx(network_idx).expect("0 or 1"),
+            account,
+        ];
+
+        let mut scan_deriv = base_deriv.clone();
+        scan_deriv.push(bip32::ChildNumber::from_hardened_idx(1).expect("1"));
+        scan_deriv.push(bip32::ChildNumber::from_normal_idx(0).expect("0"));
+
+        let mut spend_deriv = base_deriv;
+        spend_deriv.push(bip32::ChildNumber::from_hardened_idx(0).expect("0"));
+        spend_deriv.push(bip32::ChildNumber::from_normal_idx(0).expect("0"));
+
+        let scan = master_xpriv
+            .derive_priv(&secp, &scan_deriv)
+            .map_err(|_| Error::msg("Fail to derive scan key"))?
+            .private_key;
+
+        let spend = master_xpriv
+            .derive_priv(&secp, &spend_deriv)
+            .map_err(|_| Error::msg("Fail to derive spend key"))?
+            .private_key;
+
+        Self::new_inner(scan, spend.into(), network, secp)
+    }
+
             sp_network,
         )?;
 
diff --git a/sp-client/src/lib.rs b/sp-client/src/lib.rs
index 7e05259..55e9328 100644
--- a/sp-client/src/lib.rs
+++ b/sp-client/src/lib.rs
@@ -13,5 +13,7 @@ pub use updater::Updater;
 
 // Re-export commonly used external types
 pub use bdk_coin_select::FeeRate;
+#[cfg(feature = "mnemonic")]
+pub use bip39;
 pub use bitcoin;
 pub use silentpayments;