diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 0000000..125986b
--- /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"  # Commented out to allow workspace to build for native 
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index d8e963a..90f6375 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,25 +1,36 @@
-[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",
+    "backend-blindbit-wasm",
+]
+resolver = "2"
 
-[dependencies]
+[workspace.dependencies]
+# Core dependencies - shared across crates
 silentpayments = "0.4"
 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"
+bip39 = { version = "2.2.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"
 
-[features]
-blindbit-backend = ["reqwest", "hex"]
+# Performance dependencies (optional)
+rayon = "1.10.0"
+
+# Native backend dependencies
+reqwest = { version = "0.12.4", features = ["rustls-tls", "gzip", "json"], default-features = false }
+
+# WASM dependencies (for future use)
+wasm-bindgen = "0.2"
+
+[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/backend-blindbit-native/src/lib.rs b/backend-blindbit-native/src/lib.rs
new file mode 100644
index 0000000..98a8fc0
--- /dev/null
+++ b/backend-blindbit-native/src/lib.rs
@@ -0,0 +1,10 @@
+#![allow(clippy::module_inception)]
+mod backend;
+mod scanner;
+
+// Re-export backend functionality
+pub use backend::{BlindbitBackend, BlindbitClient, ChainBackend};
+pub use scanner::SpScanner;
+
+// 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
new file mode 100644
index 0000000..9716f73
--- /dev/null
+++ b/backend-blindbit-native/src/scanner/mod.rs
@@ -0,0 +1,325 @@
+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, 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)
+    /// * `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)
+        }
+    }
+}
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/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/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..ce4bb1b
--- /dev/null
+++ b/backend-blindbit-wasm/src/backend/blindbit/client/client.rs
@@ -0,0 +1,120 @@
+use anyhow::Result;
+use bitcoin::{absolute::Height, secp256k1::PublicKey, Amount, Txid};
+use reqwest::{Client, Url};
+
+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..394753a
--- /dev/null
+++ b/backend-blindbit-wasm/src/lib.rs
@@ -0,0 +1,37 @@
+//! # 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.
+
+#![allow(clippy::module_inception)]
+
+mod backend;
+mod scanner;
+
+// Re-export backend functionality
+pub use backend::{BlindbitBackend, BlindbitClient, ChainBackend};
+pub use scanner::SpScanner;
+
+use sp_client::*;
+
+pub use wasm_bindgen_futures;
diff --git a/backend-blindbit-wasm/src/scanner/mod.rs b/backend-blindbit-wasm/src/scanner/mod.rs
new file mode 100644
index 0000000..b68d57a
--- /dev/null
+++ b/backend-blindbit-wasm/src/scanner/mod.rs
@@ -0,0 +1,325 @@
+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, 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)
+    /// * `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>>>>;
+
+    /// 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,
+    ) -> 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)
+        }
+    }
+}
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..c7cd167
--- /dev/null
+++ b/sp-client/Cargo.toml
@@ -0,0 +1,29 @@
+[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 }
+
+# Optional for use bip39 mnemonics
+bip39 = { workspace = true, optional = true }
+
+[features]
+default = ["mnemonic"]
+mnemonic = ["dep:bip39"] # Enable using bip39 mnemonics for create SpClient
+parallel = ["rayon"]  # Enable parallel processing for better performance
diff --git a/src/client/client.rs b/sp-client/src/client/client.rs
similarity index 53%
rename from src/client/client.rs
rename to sp-client/src/client/client.rs
index 0a4c1d0..5fc2d8b 100644
--- a/src/client/client.rs
+++ b/sp-client/src/client/client.rs
@@ -1,14 +1,16 @@
-use std::{collections::HashMap, io::Write, str::FromStr};
+use std::io::Write;
 
 use bitcoin::hashes::Hash;
 use bitcoin::{
-    key::constants::ONE,
-    secp256k1::{PublicKey, Scalar, Secp256k1, SecretKey},
-    Network, XOnlyPublicKey,
+    secp256k1::{Secp256k1, SecretKey},
+    Network,
 };
 use serde::{Deserialize, Serialize};
 
+use bitcoin::secp256k1::{All, PublicKey};
 use silentpayments::utils as sp_utils;
+use std::collections::HashMap;
+
 use silentpayments::Network as SpNetwork;
 use silentpayments::{
     bitcoin_hashes::sha256,
@@ -18,7 +20,18 @@ 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,
+};
+
+#[cfg(feature = "mnemonic")]
+use bitcoin::bip32;
 
 use super::SpendKey;
 
@@ -30,6 +43,7 @@ pub struct SpClient {
     network: Network,
 }
 
+#[cfg(test)]
 impl Default for SpClient {
     fn default() -> Self {
         let default_sk = SecretKey::from_slice(&[0xcd; 32]).unwrap();
@@ -54,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);
 
@@ -70,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,
         )?;
 
@@ -108,14 +193,24 @@ impl SpClient {
         &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| {
@@ -125,6 +220,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 97%
rename from src/client/spend.rs
rename to sp-client/src/client/spend.rs
index bb14afe..240b5f9 100644
--- a/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/src/client/structs.rs b/sp-client/src/client/structs.rs
similarity index 92%
rename from src/client/structs.rs
rename to sp-client/src/client/structs.rs
index dccc587..d0ae745 100644
--- a/src/client/structs.rs
+++ b/sp-client/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 {
@@ -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) {
@@ -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> {
@@ -110,6 +116,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/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..55e9328
--- /dev/null
+++ b/sp-client/src/lib.rs
@@ -0,0 +1,19 @@
+#![allow(clippy::module_inception)]
+
+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;
+#[cfg(feature = "mnemonic")]
+pub use bip39;
+pub use bitcoin;
+pub use silentpayments;
diff --git a/src/backend/structs.rs b/sp-client/src/types.rs
similarity index 100%
rename from src/backend/structs.rs
rename to sp-client/src/types.rs
diff --git a/src/updater/mod.rs b/sp-client/src/updater/mod.rs
similarity index 100%
rename from src/updater/mod.rs
rename to sp-client/src/updater/mod.rs
diff --git a/src/updater/updater.rs b/sp-client/src/updater/updater.rs
similarity index 96%
rename from src/updater/updater.rs
rename to sp-client/src/updater/updater.rs
index 28ff001..f8abb87 100644
--- a/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.
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 c055981..0000000
--- a/src/lib.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-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 backend::*;
-pub use client::*;
-pub use scanner::SpScanner;
-pub use updater::Updater;
diff --git a/src/scanner/mod.rs b/src/scanner/mod.rs
deleted file mode 100644
index 2d6bea2..0000000
--- a/src/scanner/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-mod scanner;
-
-pub use scanner::SpScanner;
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)
-    }
-}
diff --git a/test-compilation.sh b/test-compilation.sh
new file mode 100755
index 0000000..c543fc4
--- /dev/null
+++ b/test-compilation.sh
@@ -0,0 +1,67 @@
+#!/bin/bash
+
+set -e  # Exit on any error
+
+echo "🧪 Testing All Compilation Scenarios"
+echo "===================================="
+
+echo ""
+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 (excluding WASM backend)..."
+cargo check --workspace --exclude backend-blindbit-wasm --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 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: Native backend should NOT compile for WASM!"
+    exit 1
+else
+    echo "✅ Good! Native backend correctly fails to compile for WASM"
+fi
+
+echo ""
+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!"
+echo ""
+echo "Summary:"
+echo "--------"
+echo "✅ Core client compiles for native and WASM"
+echo "✅ Core client works with and without features"
+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)"