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/15] 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 b5fa5364cea07f12aca05aec83a0d9baf75814e2 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Sat, 21 Jun 2025 13:40:35 +0200
Subject: [PATCH 02/15] Add wasm dependencies + separate targets

---
 .cargo/config.toml | 12 ++++++++++++
 Cargo.toml         | 17 ++++++++++++++++-
 2 files changed, 28 insertions(+), 1 deletion(-)
 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..57fd02d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,6 @@ 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"
@@ -21,5 +20,21 @@ reqwest = { version = "0.12.4", features = ["rustls-tls", "gzip", "json"], defau
 hex = { version = "0.4.3", features = ["serde"], optional = true }
 bdk_coin_select = "0.4.0"
 
+# WASM-incompatible dependencies - only include when not targeting WASM
+rayon = { version = "1.10.0", optional = true }
+
+# WASM-specific dependencies
+wasm-bindgen = { version = "0.2", optional = true }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+rayon = "1.10.0"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-bindgen = "0.2"
+
 [features]
 blindbit-backend = ["reqwest", "hex"]
+default = []
+
+# WASM-specific features
+wasm = ["wasm-bindgen"]

From 3be073c6c5ec7b64205c5954608f7e931b070169 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Sat, 21 Jun 2025 13:41:43 +0200
Subject: [PATCH 03/15] wasm compatibility refactoring

---
 src/backend/backend.rs                  | 18 +++++++
 src/backend/blindbit/backend/backend.rs | 72 ++++++++++++++++++++++++-
 src/backend/mod.rs                      |  4 ++
 src/client/client.rs                    | 58 +++++++++++++-------
 4 files changed, 133 insertions(+), 19 deletions(-)

diff --git a/src/backend/backend.rs b/src/backend/backend.rs
index d1892f0..55dc15c 100644
--- a/src/backend/backend.rs
+++ b/src/backend/backend.rs
@@ -22,3 +22,21 @@ pub trait ChainBackend {
 
     async fn block_height(&self) -> Result<Height>;
 }
+
+// WASM-specific version without Send bounds
+#[cfg(target_arch = "wasm32")]
+#[async_trait(?Send)]
+pub trait ChainBackendWasm {
+    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/src/backend/blindbit/backend/backend.rs b/src/backend/blindbit/backend/backend.rs
index ba47e70..ed3b77d 100644
--- a/src/backend/blindbit/backend/backend.rs
+++ b/src/backend/blindbit/backend/backend.rs
@@ -1,4 +1,7 @@
-use std::{ops::RangeInclusive, pin::Pin, sync::Arc};
+use std::{ops::RangeInclusive, pin::Pin};
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::sync::Arc;
 
 use async_trait::async_trait;
 use bitcoin::{absolute::Height, Amount};
@@ -8,6 +11,9 @@ use anyhow::Result;
 
 use crate::{backend::blindbit::BlindbitClient, BlockData, ChainBackend, SpentIndexData, UtxoData};
 
+#[cfg(target_arch = "wasm32")]
+use crate::backend::ChainBackendWasm;
+
 const CONCURRENT_FILTER_REQUESTS: usize = 200;
 
 #[derive(Debug)]
@@ -23,6 +29,7 @@ impl BlindbitBackend {
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 #[async_trait]
 impl ChainBackend for BlindbitBackend {
     /// High-level function to get block data for a range of blocks.
@@ -82,3 +89,66 @@ impl ChainBackend for BlindbitBackend {
         self.client.block_height().await
     }
 }
+
+#[cfg(target_arch = "wasm32")]
+#[async_trait(?Send)]
+impl ChainBackendWasm 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>>>> {
+        // For WASM, we need to avoid Arc and use a different approach
+        // Since WASM doesn't support threading well, we'll use a simpler approach
+        let client = 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(1); // Use buffered(1) for WASM to avoid concurrency issues
+
+        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/src/backend/mod.rs b/src/backend/mod.rs
index d81e60c..89c767e 100644
--- a/src/backend/mod.rs
+++ b/src/backend/mod.rs
@@ -4,6 +4,10 @@ mod blindbit;
 mod structs;
 
 pub use backend::ChainBackend;
+
+#[cfg(target_arch = "wasm32")]
+pub use backend::ChainBackendWasm;
+
 pub use structs::*;
 
 #[cfg(feature = "blindbit-backend")]
diff --git a/src/client/client.rs b/src/client/client.rs
index 0a4c1d0..e80b793 100644
--- a/src/client/client.rs
+++ b/src/client/client.rs
@@ -108,30 +108,52 @@ impl SpClient {
         &self,
         tweak_data_vec: Vec<PublicKey>,
     ) -> Result<HashMap<[u8; 34], PublicKey>> {
-        use rayon::prelude::*;
         let b_scan = &self.get_scan_key();
 
-        let shared_secrets: Vec<PublicKey> = tweak_data_vec
-            .into_par_iter()
-            .map(|tweak| sp_utils::receiving::calculate_ecdh_shared_secret(&tweak, b_scan))
-            .collect();
-
-        let items: Result<Vec<_>> = shared_secrets
-            .into_par_iter()
-            .map(|secret| {
-                let spks = self.sp_receiver.get_spks_from_shared_secret(&secret)?;
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            use rayon::prelude::*;
+            
+            let shared_secrets: Vec<PublicKey> = tweak_data_vec
+                .into_par_iter()
+                .map(|tweak| sp_utils::receiving::calculate_ecdh_shared_secret(&tweak, b_scan))
+                .collect();
+
+            let items: Result<Vec<_>> = shared_secrets
+                .into_par_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 {
+                    res.insert(spk, secret);
+                }
+            }
+            Ok(res)
+        }
 
-                Ok((secret, spks.into_values()))
-            })
-            .collect();
+        #[cfg(target_arch = "wasm32")]
+        {
+            // Sequential fallback for WASM
+            let shared_secrets: Vec<PublicKey> = tweak_data_vec
+                .into_iter()
+                .map(|tweak| sp_utils::receiving::calculate_ecdh_shared_secret(&tweak, b_scan))
+                .collect();
 
-        let mut res = HashMap::new();
-        for (secret, spks) in items? {
-            for spk in spks {
-                res.insert(spk, secret);
+            let mut res = HashMap::new();
+            for secret in shared_secrets {
+                let spks = self.sp_receiver.get_spks_from_shared_secret(&secret)?;
+                for spk in spks.into_values() {
+                    res.insert(spk, secret);
+                }
             }
+            Ok(res)
         }
-        Ok(res)
     }
 
     pub fn get_client_fingerprint(&self) -> Result<[u8; 8]> {

From 8566f713ad0d2532c65491532dc975d56d9364db Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Sat, 21 Jun 2025 13:42:03 +0200
Subject: [PATCH 04/15] update examples

---
 examples/Cargo.toml |  15 +++++++
 examples/lib.rs     | 105 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 120 insertions(+)
 create mode 100644 examples/Cargo.toml
 create mode 100644 examples/lib.rs

diff --git a/examples/Cargo.toml b/examples/Cargo.toml
new file mode 100644
index 0000000..b2e2db6
--- /dev/null
+++ b/examples/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "wasm_example"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sp_client = { path = ".." }
+bitcoin = { version = "0.31.1", features = ["serde", "rand", "base64"] }
+hex = "0.4.3"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-bindgen = "0.2"
+
+[lib]
+crate-type = ["cdylib"] 
\ No newline at end of file
diff --git a/examples/lib.rs b/examples/lib.rs
new file mode 100644
index 0000000..4f9cbe4
--- /dev/null
+++ b/examples/lib.rs
@@ -0,0 +1,105 @@
+//! Example of using sp_client in a WASM environment
+//! 
+//! This example shows how to create a basic silent payment client
+//! and generate receiving addresses in a WASM context.
+
+use sp_client::{SpClient, SpendKey};
+use bitcoin::{Network, secp256k1::SecretKey};
+
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::prelude::*;
+
+/// Create a new silent payment client for WASM
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+pub fn create_client(scan_key_hex: &str, network: &str) -> Result<String, JsValue> {
+    // Parse the scan key
+    let scan_key_bytes = hex::decode(scan_key_hex)
+        .map_err(|e| JsValue::from_str(&format!("Invalid scan key: {}", e)))?;
+    let scan_sk = SecretKey::from_slice(&scan_key_bytes)
+        .map_err(|e| JsValue::from_str(&format!("Invalid secret key: {}", e)))?;
+    
+    // Parse network
+    let network = match network {
+        "bitcoin" => Network::Bitcoin,
+        "testnet" => Network::Testnet,
+        "regtest" => Network::Regtest,
+        "signet" => Network::Signet,
+        _ => return Err(JsValue::from_str("Invalid network")),
+    };
+    
+    // Create spend key (using scan key as spend key for this example)
+    let spend_key = SpendKey::Secret(scan_sk);
+    
+    // Create client
+    let client = SpClient::new(scan_sk, spend_key, network)
+        .map_err(|e| JsValue::from_str(&format!("Failed to create client: {}", e)))?;
+    
+    // Get receiving address
+    let address = client.get_receiving_address();
+    
+    Ok(address.to_string())
+}
+
+/// Get client fingerprint for WASM
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+pub fn get_fingerprint(scan_key_hex: &str, network: &str) -> Result<String, JsValue> {
+    // Parse the scan key
+    let scan_key_bytes = hex::decode(scan_key_hex)
+        .map_err(|e| JsValue::from_str(&format!("Invalid scan key: {}", e)))?;
+    let scan_sk = SecretKey::from_slice(&scan_key_bytes)
+        .map_err(|e| JsValue::from_str(&format!("Invalid secret key: {}", e)))?;
+    
+    // Parse network
+    let network = match network {
+        "bitcoin" => Network::Bitcoin,
+        "testnet" => Network::Testnet,
+        "regtest" => Network::Regtest,
+        "signet" => Network::Signet,
+        _ => return Err(JsValue::from_str("Invalid network")),
+    };
+    
+    // Create spend key (using scan key as spend key for this example)
+    let spend_key = SpendKey::Secret(scan_sk);
+    
+    // Create client
+    let client = SpClient::new(scan_sk, spend_key, network)
+        .map_err(|e| JsValue::from_str(&format!("Failed to create client: {}", e)))?;
+    
+    // Get fingerprint
+    let fingerprint = client.get_client_fingerprint()
+        .map_err(|e| JsValue::from_str(&format!("Failed to get fingerprint: {}", e)))?;
+    
+    Ok(hex::encode(fingerprint))
+}
+
+// Non-WASM example for testing
+#[cfg(not(target_arch = "wasm32"))]
+pub fn create_client_example() -> Result<String, Box<dyn std::error::Error>> {
+    // Create a test scan key
+    let scan_sk = SecretKey::from_slice(&[0x01; 32])?;
+    let spend_key = SpendKey::Secret(scan_sk);
+    
+    // Create client for testnet
+    let client = SpClient::new(scan_sk, spend_key, Network::Testnet)?;
+    
+    // Get receiving address
+    let address = client.get_receiving_address();
+    
+    Ok(address.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))]
+    fn test_create_client() {
+        let result = create_client_example();
+        assert!(result.is_ok());
+        let address = result.unwrap();
+        assert!(address.starts_with("sp"));
+    }
+} 
\ No newline at end of file

From 71862a092878931065e230c7533e6e2f7c3d6d6b Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Sat, 21 Jun 2025 13:42:23 +0200
Subject: [PATCH 05/15] Update README

---
 README.md | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/README.md b/README.md
index 81c3bc9..bc06c45 100644
--- a/README.md
+++ b/README.md
@@ -7,3 +7,42 @@ Whereas rust-silentpayments concerns itself with cryptography (it is essentially
 sp-client is concerned with high-level wallet stuff, such as parsing incoming transactions, managing owned outputs, and signing transactions.
 
 This library is used as a backend for the silent payment wallet [Dana wallet](https://github.com/cygnet3/danawallet).
+
+## WASM Support
+
+This library supports WebAssembly (WASM) targets for use in web applications. To build for WASM:
+
+### Prerequisites
+
+1. Install the WASM target:
+   ```bash
+   rustup target add wasm32-unknown-unknown
+   ```
+
+2. Install wasm-pack (optional, for easier WASM builds):
+   ```bash
+   cargo install wasm-pack
+   ```
+
+### Building for WASM
+
+#### Using Cargo directly:
+```bash
+cargo build --target wasm32-unknown-unknown
+```
+
+#### Using wasm-pack:
+```bash
+wasm-pack build --target web
+```
+
+### Features
+
+When building for WASM:
+- The `rayon` dependency is automatically disabled and parallel processing falls back to sequential processing
+- The `blindbit-backend` feature is available but requires appropriate HTTP client configuration for WASM
+- All core functionality remains available
+
+### Usage in Web Applications
+
+The library can be used in web applications through standard WASM interop. Note that some features like the `blindbit-backend` may require additional configuration for HTTP requests in the browser environment.

From ba560596f2da8f0e9829db0e59a7bd5841f41e22 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Sat, 21 Jun 2025 17:11:10 +0200
Subject: [PATCH 06/15] 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 260024f7065c969e2224364d69f785af6a99611c Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Tue, 24 Jun 2025 15:18:21 +0200
Subject: [PATCH 07/15] Rewrite the backend to be compatible with wasm

* Abstraction of SpScanner into a trait
* Gating of the code with wasm32 target when necessary
---
 src/backend/backend.rs                  |   1 +
 src/backend/blindbit/backend/backend.rs |   5 +-
 src/backend/mod.rs                      |   5 +-
 src/scanner/mod.rs                      | 345 ++++++++++++++++++++-
 src/scanner/scanner.rs                  | 380 ------------------------
 5 files changed, 351 insertions(+), 385 deletions(-)
 delete mode 100644 src/scanner/scanner.rs

diff --git a/src/backend/backend.rs b/src/backend/backend.rs
index 55dc15c..26a86d2 100644
--- a/src/backend/backend.rs
+++ b/src/backend/backend.rs
@@ -7,6 +7,7 @@ use futures::Stream;
 
 use super::structs::{BlockData, SpentIndexData, UtxoData};
 
+#[cfg(not(target_arch = "wasm32"))]
 #[async_trait]
 pub trait ChainBackend {
     fn get_block_data_for_range(
diff --git a/src/backend/blindbit/backend/backend.rs b/src/backend/blindbit/backend/backend.rs
index ed3b77d..866f374 100644
--- a/src/backend/blindbit/backend/backend.rs
+++ b/src/backend/blindbit/backend/backend.rs
@@ -9,7 +9,10 @@ use futures::{stream, Stream, StreamExt};
 
 use anyhow::Result;
 
-use crate::{backend::blindbit::BlindbitClient, BlockData, ChainBackend, SpentIndexData, UtxoData};
+use crate::{backend::blindbit::BlindbitClient, BlockData, SpentIndexData, UtxoData};
+
+#[cfg(not(target_arch = "wasm32"))]
+use crate::backend::ChainBackend;
 
 #[cfg(target_arch = "wasm32")]
 use crate::backend::ChainBackendWasm;
diff --git a/src/backend/mod.rs b/src/backend/mod.rs
index 89c767e..1dd45aa 100644
--- a/src/backend/mod.rs
+++ b/src/backend/mod.rs
@@ -3,11 +3,12 @@ mod backend;
 mod blindbit;
 mod structs;
 
-pub use backend::ChainBackend;
-
 #[cfg(target_arch = "wasm32")]
 pub use backend::ChainBackendWasm;
 
+#[cfg(not(target_arch = "wasm32"))]
+pub use backend::ChainBackend;
+
 pub use structs::*;
 
 #[cfg(feature = "blindbit-backend")]
diff --git a/src/scanner/mod.rs b/src/scanner/mod.rs
index 2d6bea2..e35437c 100644
--- a/src/scanner/mod.rs
+++ b/src/scanner/mod.rs
@@ -1,3 +1,344 @@
-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,
+};
+
+#[cfg(not(target_arch = "wasm32"))]
+use crate::backend::ChainBackend;
+
+#[cfg(target_arch = "wasm32")]
+use crate::backend::ChainBackendWasm;
+
+/// 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
+    #[cfg(not(target_arch = "wasm32"))]
+    fn backend(&self) -> &dyn ChainBackend;
+
+    /// Get the chain backend (WASM version)
+    #[cfg(target_arch = "wasm32")]
+    fn backend(&self) -> &dyn ChainBackendWasm;
+
+    /// 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 509e8fc5deb65fd5bf6e05dbbbe204ba0c27eef2 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Wed, 13 Aug 2025 20:51:36 +0200
Subject: [PATCH 08/15] Add dependencies and gating in Cargo file

---
 Cargo.toml | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 57fd02d..4b219b4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,7 +5,12 @@ edition = "2021"
 
 [lib]
 name = "sp_client"
-crate-type = ["lib", "staticlib", "cdylib"]
+
+[target.'cfg(target_arch = "wasm32")'.lib]
+crate-type = ["cdylib", "rlib"]
+
+[target.'cfg(not(target_arch = "wasm32"))'.lib]
+crate-type = ["lib", "staticlib", "cdylib", "rlib"]
 
 [dependencies]
 silentpayments = "0.4"
@@ -28,9 +33,13 @@ wasm-bindgen = { version = "0.2", optional = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 rayon = "1.10.0"
+reqwest = { version = "0.12.4", features = ["rustls-tls", "gzip", "json"], default-features = false }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen = "0.2"
+js-sys = "0.3"
+wasm-bindgen-futures = "0.4"
+serde-wasm-bindgen = "0.6.5"
 
 [features]
 blindbit-backend = ["reqwest", "hex"]

From ba1980eeb23d990a8b3909eac1c016db88d33367 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Wed, 13 Aug 2025 20:52:37 +0200
Subject: [PATCH 09/15] Add http_client mod

---
 src/backend/http_client.rs | 103 +++++++++++++++++++++++++++++++++++++
 src/backend/mod.rs         |   1 +
 2 files changed, 104 insertions(+)
 create mode 100644 src/backend/http_client.rs

diff --git a/src/backend/http_client.rs b/src/backend/http_client.rs
new file mode 100644
index 0000000..7e732c2
--- /dev/null
+++ b/src/backend/http_client.rs
@@ -0,0 +1,103 @@
+use async_trait::async_trait;
+use anyhow::Result;
+use serde::{de::DeserializeOwned, Serialize};
+
+// Define the trait differently for WASM vs native
+#[cfg(not(target_arch = "wasm32"))]
+#[async_trait]
+pub trait HttpClient {
+    async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T>;
+    async fn post<T: DeserializeOwned>(&self, url: &str, body: &(impl Serialize + Sync)) -> Result<T>;
+}
+
+#[cfg(target_arch = "wasm32")]
+#[async_trait(?Send)]
+pub trait HttpClient {
+    async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T>;
+    async fn post<T: DeserializeOwned>(&self, url: &str, body: &(impl Serialize + Sync)) -> Result<T>;
+}
+
+// Native implementation using reqwest
+#[cfg(not(target_arch = "wasm32"))]
+#[derive(Clone, Debug)]
+pub struct NativeHttpClient {
+    client: reqwest::Client,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl NativeHttpClient {
+    pub fn new() -> Self {
+        Self {
+            client: reqwest::Client::new(),
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[async_trait]
+impl HttpClient for NativeHttpClient {
+    async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T> {
+        let response = self.client.get(url).send().await?;
+        let text: String = response.text().await?;
+        Ok(serde_json::from_str(&text)?)
+    }
+
+    async fn post<T: DeserializeOwned>(&self, url: &str, body: &(impl Serialize + Sync)) -> Result<T> {
+        let response = self.client.post(url).json(body).send().await?;
+        let text: String = response.text().await?;
+        Ok(serde_json::from_str(&text)?)
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::prelude::*;
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen_futures::JsFuture;
+#[cfg(target_arch = "wasm32")]
+use js_sys::Promise;
+
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+extern "C" {
+    pub type JsHttpClient;
+
+    #[wasm_bindgen(method, catch)]
+    fn get(this: &JsHttpClient, url: &str) -> Result<Promise, JsValue>;
+
+    #[wasm_bindgen(method, catch)]
+    fn post(this: &JsHttpClient, url: &str, body: &JsValue) -> Result<Promise, JsValue>;
+}
+
+#[cfg(target_arch = "wasm32")]
+pub struct WasmHttpClient {
+    pub inner: JsHttpClient,
+}
+
+#[cfg(target_arch = "wasm32")]
+impl WasmHttpClient {
+    pub fn new(inner: JsHttpClient) -> Self {
+        Self { inner }
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+#[async_trait::async_trait(?Send)]
+impl HttpClient for WasmHttpClient {
+    async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T> {
+        let p = self.inner.get(url).map_err(|e| anyhow::anyhow!("get() threw: {:?}", e))?;
+        let v = JsFuture::from(p).await.map_err(|e| anyhow::anyhow!("promise rejected: {:?}", e))?;
+        let t: T = serde_wasm_bindgen::from_value(v)
+            .map_err(|e| anyhow::anyhow!("deserialize error: {}", e))?;
+        Ok(t)
+    }
+
+    async fn post<T: DeserializeOwned>(&self, url: &str, body: &(impl Serialize + Sync)) -> Result<T> {
+        let body_js = serde_wasm_bindgen::to_value(body)
+            .map_err(|e| anyhow::anyhow!("serialize body error: {}", e))?;
+        let p = self.inner.post(url, &body_js).map_err(|e| anyhow::anyhow!("post() threw: {:?}", e))?;
+        let v = JsFuture::from(p).await.map_err(|e| anyhow::anyhow!("promise rejected: {:?}", e))?;
+        let t: T = serde_wasm_bindgen::from_value(v)
+            .map_err(|e| anyhow::anyhow!("deserialize error: {}", e))?;
+        Ok(t)
+    }
+}
diff --git a/src/backend/mod.rs b/src/backend/mod.rs
index 1dd45aa..f729e82 100644
--- a/src/backend/mod.rs
+++ b/src/backend/mod.rs
@@ -1,6 +1,7 @@
 mod backend;
 #[cfg(feature = "blindbit-backend")]
 mod blindbit;
+mod http_client;
 mod structs;
 
 #[cfg(target_arch = "wasm32")]

From 244ee8cbc625afc98f0f4bf5c91969ac111f8100 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Wed, 13 Aug 2025 20:54:48 +0200
Subject: [PATCH 10/15] Implement Wasm/NativeBlindbitClient

---
 src/backend/blindbit/client/client.rs | 193 ++++++++++++++------------
 src/backend/blindbit/client/mod.rs    |   8 +-
 2 files changed, 114 insertions(+), 87 deletions(-)

diff --git a/src/backend/blindbit/client/client.rs b/src/backend/blindbit/client/client.rs
index 8b1e730..12e3390 100644
--- a/src/backend/blindbit/client/client.rs
+++ b/src/backend/blindbit/client/client.rs
@@ -1,128 +1,149 @@
-use std::time::Duration;
-
 use bitcoin::{absolute::Height, secp256k1::PublicKey, Amount, Txid};
-use reqwest::{Client, Url};
-
 use anyhow::Result;
 
+use crate::backend::http_client::HttpClient;
+#[cfg(target_arch = "wasm32")]
+use crate::backend::http_client::WasmHttpClient;
+#[cfg(not(target_arch = "wasm32"))]
+use crate::backend::http_client::NativeHttpClient;
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::prelude::*;
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::JsCast;
+#[cfg(target_arch = "wasm32")]
+use std::rc::Rc;
+
 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 trait BlindbitClient {
+    type Client: HttpClient;
 
-    pub async fn block_height(&self) -> Result<Height> {
-        let url = self.host_url.join("block-height")?;
+    fn host_url(&self) -> &str;
+    fn http_client(&self) -> &Self::Client;
 
-        let res = self
-            .client
-            .get(url)
-            .timeout(Duration::from_secs(5))
-            .send()
-            .await?;
-        let blkheight: BlockHeightResponse = serde_json::from_str(&res.text().await?)?;
+    async fn block_height(&self) -> Result<Height> {
+        let url = format!("{}block-height", self.host_url());
+        let blkheight: BlockHeightResponse = self.http_client().get(&url).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?)?)
+    async fn tweaks(&self, block_height: Height, dust_limit: Amount) -> Result<Vec<PublicKey>> {
+        let url = format!("{}tweaks/{}?dustLimit={}", self.host_url(), block_height, dust_limit.to_sat());
+        Ok(self.http_client().get(&url).await?)
     }
 
-    pub async fn tweak_index(
+    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?)?)
+        let url = format!("{}tweak-index/{}?dustLimit={}", self.host_url(), block_height, dust_limit.to_sat());
+        Ok(self.http_client().get(&url).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?)?)
+    async fn utxos(&self, block_height: Height) -> Result<Vec<UtxoResponse>> {
+        let url = format!("{}utxos/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).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?;
+    async fn spent_index(&self, block_height: Height) -> Result<SpentIndexResponse> {
+        let url = format!("{}spent-index/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).await?)
+    }
 
-        Ok(serde_json::from_str(&res.text().await?)?)
+    async fn filter_new_utxos(&self, block_height: Height) -> Result<FilterResponse> {
+        let url = format!("{}filter/new-utxos/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).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))?;
+    async fn filter_spent(&self, block_height: Height) -> Result<FilterResponse> {
+        let url = format!("{}filter/spent/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).await?)
+    }
 
-        let res = self.client.get(url).send().await?;
+    async fn forward_tx(&self, tx_hex: String) -> Result<Txid> {
+        let url = format!("{}forward-tx", self.host_url());
+        let body = ForwardTxRequest::new(tx_hex);
+        Ok(self.http_client().post(&url, &body).await?)
+    }
 
-        Ok(serde_json::from_str(&res.text().await?)?)
+    async fn info(&self) -> Result<InfoResponse> {
+        let url = format!("{}info", self.host_url());
+        Ok(self.http_client().get(&url).await?)
     }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub struct NativeBlindbitClient {
+    http_client: NativeHttpClient,
+    host_url: String,
+}
 
-    pub async fn filter_spent(&self, block_height: Height) -> Result<FilterResponse> {
-        let url = self
-            .host_url
-            .join(&format!("filter/spent/{}", block_height))?;
+#[cfg(not(target_arch = "wasm32"))]
+impl NativeBlindbitClient {
+    pub fn new(host_url: String) -> Self {
+        let mut host_url = host_url;
+        
+        // we need a trailing slash, if not present we append it
+        if !host_url.ends_with('/') {
+            host_url.push('/');
+        }
 
-        let res = self.client.get(url).send().await?;
+        let http_client = NativeHttpClient::new();
 
-        Ok(serde_json::from_str(&res.text().await?)?)
+        Self { http_client, host_url }
     }
 
-    pub async fn forward_tx(&self, tx_hex: String) -> Result<Txid> {
-        let url = self.host_url.join("forward-tx")?;
+    pub fn host_url(&self) -> &str {
+        &self.host_url
+    }
 
-        let body = ForwardTxRequest::new(tx_hex);
+    pub fn http_client(&self) -> &NativeHttpClient {
+        &self.http_client
+    }
+}
 
-        let res = self.client.post(url).json(&body).send().await?;
+#[cfg(not(target_arch = "wasm32"))]
+impl BlindbitClient for NativeBlindbitClient {
+    type Client = NativeHttpClient;
 
-        Ok(serde_json::from_str(&res.text().await?)?)
-    }
+    fn host_url(&self) -> &str { &self.host_url }
+    fn http_client(&self) -> &Self::Client { &self.http_client }
+}
 
-    pub async fn info(&self) -> Result<InfoResponse> {
-        let url = self.host_url.join("info")?;
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+#[derive(Clone)]
+pub struct WasmBlindbitClient {
+    http_client: Rc<WasmHttpClient>,
+    host_url: String,
+}
 
-        let res = self.client.get(url).send().await?;
-        Ok(serde_json::from_str(&res.text().await?)?)
+#[cfg(target_arch = "wasm32")]
+impl WasmBlindbitClient {
+    pub fn http_client(&self) -> &WasmHttpClient { self.http_client.as_ref() }
+}
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+impl WasmBlindbitClient {
+    #[wasm_bindgen(constructor)]
+    pub fn new(host_url: String, http_client: JsValue) -> Self {
+        let js_client = http_client.dyn_into().unwrap_or_else(|_| {
+            wasm_bindgen::throw_str("Failed to convert to JsHttpClient");
+        });
+        let wasm_client = WasmHttpClient::new(js_client);
+        Self { http_client: Rc::new(wasm_client), host_url }
     }
 }
+
+#[cfg(target_arch = "wasm32")]
+impl BlindbitClient for WasmBlindbitClient {
+    type Client = WasmHttpClient;
+
+    fn host_url(&self) -> &str { &self.host_url }
+    fn http_client(&self) -> &Self::Client { self.http_client.as_ref() }
+}
diff --git a/src/backend/blindbit/client/mod.rs b/src/backend/blindbit/client/mod.rs
index 82f00d4..4a86e62 100644
--- a/src/backend/blindbit/client/mod.rs
+++ b/src/backend/blindbit/client/mod.rs
@@ -1,4 +1,10 @@
-mod client;
+pub mod client;
 pub mod structs;
 
+#[cfg(target_arch = "wasm32")]
+pub use client::WasmBlindbitClient;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use client::NativeBlindbitClient;
+
 pub use client::BlindbitClient;

From 549451b91745ea49ae3c3948887d90827b6ab805 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Wed, 13 Aug 2025 20:55:10 +0200
Subject: [PATCH 11/15] Implement Wasm/NativeBlindbitBackend

---
 src/backend/blindbit/backend/backend.rs | 49 +++++++++++++++++++------
 src/backend/blindbit/backend/mod.rs     |  5 ++-
 2 files changed, 41 insertions(+), 13 deletions(-)

diff --git a/src/backend/blindbit/backend/backend.rs b/src/backend/blindbit/backend/backend.rs
index 866f374..2b294d6 100644
--- a/src/backend/blindbit/backend/backend.rs
+++ b/src/backend/blindbit/backend/backend.rs
@@ -9,7 +9,16 @@ use futures::{stream, Stream, StreamExt};
 
 use anyhow::Result;
 
-use crate::{backend::blindbit::BlindbitClient, BlockData, SpentIndexData, UtxoData};
+use crate::{
+    BlockData, SpentIndexData, UtxoData
+};
+
+use crate::backend::blindbit::client::BlindbitClient;
+
+#[cfg(not(target_arch = "wasm32"))]
+use crate::backend::blindbit::client::NativeBlindbitClient;
+#[cfg(target_arch = "wasm32")]
+use crate::backend::blindbit::client::WasmBlindbitClient;
 
 #[cfg(not(target_arch = "wasm32"))]
 use crate::backend::ChainBackend;
@@ -19,22 +28,23 @@ use crate::backend::ChainBackendWasm;
 
 const CONCURRENT_FILTER_REQUESTS: usize = 200;
 
-#[derive(Debug)]
-pub struct BlindbitBackend {
-    client: BlindbitClient,
+#[cfg(not(target_arch = "wasm32"))]
+pub struct NativeBlindbitBackend {
+    client: NativeBlindbitClient,
 }
 
-impl BlindbitBackend {
-    pub fn new(blindbit_url: String) -> Result<Self> {
-        Ok(Self {
-            client: BlindbitClient::new(blindbit_url)?,
-        })
+#[cfg(not(target_arch = "wasm32"))]
+impl NativeBlindbitBackend {
+    pub fn new(blindbit_client: NativeBlindbitClient) -> Self {
+        Self {
+            client: blindbit_client
+        }
     }
 }
 
 #[cfg(not(target_arch = "wasm32"))]
 #[async_trait]
-impl ChainBackend for BlindbitBackend {
+impl ChainBackend for NativeBlindbitBackend {
     /// 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.
@@ -45,7 +55,7 @@ impl ChainBackend for BlindbitBackend {
         dust_limit: Amount,
         with_cutthrough: bool,
     ) -> Pin<Box<dyn Stream<Item = Result<BlockData>> + Send>> {
-        let client = Arc::new(self.client.clone());
+        let client = Arc::new(NativeBlindbitClient::new(self.client.host_url().to_string()));
 
         let res = stream::iter(range)
             .map(move |n| {
@@ -93,9 +103,24 @@ impl ChainBackend for BlindbitBackend {
     }
 }
 
+#[cfg(target_arch = "wasm32")]
+pub struct WasmBlindbitBackend {
+    client: WasmBlindbitClient,
+}
+
+#[cfg(target_arch = "wasm32")]
+impl WasmBlindbitBackend {
+    pub fn new(blindbit_client: WasmBlindbitClient) -> Self {
+        Self {
+            client: blindbit_client
+        }
+    }
+}
+
+
 #[cfg(target_arch = "wasm32")]
 #[async_trait(?Send)]
-impl ChainBackendWasm for BlindbitBackend {
+impl ChainBackendWasm for WasmBlindbitBackend {
     /// 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.
diff --git a/src/backend/blindbit/backend/mod.rs b/src/backend/blindbit/backend/mod.rs
index e48b365..eafbc68 100644
--- a/src/backend/blindbit/backend/mod.rs
+++ b/src/backend/blindbit/backend/mod.rs
@@ -1,3 +1,6 @@
 mod backend;
 
-pub use backend::BlindbitBackend;
+#[cfg(target_arch = "wasm32")]
+pub use backend::WasmBlindbitBackend;
+#[cfg(not(target_arch = "wasm32"))]
+pub use backend::NativeBlindbitBackend;

From 937914c149fc55931b9f42285321643f3c1705ef Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Wed, 13 Aug 2025 20:57:07 +0200
Subject: [PATCH 12/15] Reexport all types

---
 src/backend/blindbit/mod.rs | 17 +++++++++++++----
 src/backend/mod.rs          | 14 ++++++++++++--
 2 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/backend/blindbit/mod.rs b/src/backend/blindbit/mod.rs
index 4dc245c..c17ad9e 100644
--- a/src/backend/blindbit/mod.rs
+++ b/src/backend/blindbit/mod.rs
@@ -1,5 +1,14 @@
-mod backend;
-mod client;
+pub mod backend;
+pub mod client;
 
-pub use backend::BlindbitBackend;
-pub use client::BlindbitClient;
+#[cfg(target_arch = "wasm32")]
+pub use backend::WasmBlindbitBackend;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use backend::NativeBlindbitBackend;
+
+#[cfg(target_arch = "wasm32")]
+pub use client::WasmBlindbitClient;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use client::NativeBlindbitClient;
\ No newline at end of file
diff --git a/src/backend/mod.rs b/src/backend/mod.rs
index f729e82..af37d07 100644
--- a/src/backend/mod.rs
+++ b/src/backend/mod.rs
@@ -13,7 +13,17 @@ pub use backend::ChainBackend;
 pub use structs::*;
 
 #[cfg(feature = "blindbit-backend")]
-pub use blindbit::BlindbitBackend;
+#[cfg(not(target_arch = "wasm32"))]
+pub use blindbit::backend::NativeBlindbitBackend;
+
+#[cfg(feature = "blindbit-backend")]
+#[cfg(target_arch = "wasm32")]
+pub use blindbit::backend::WasmBlindbitBackend;
 
+#[cfg(target_arch = "wasm32")]
+#[cfg(feature = "blindbit-backend")]
+pub use blindbit::client::client::WasmBlindbitClient;
+
+#[cfg(not(target_arch = "wasm32"))]
 #[cfg(feature = "blindbit-backend")]
-pub use blindbit::BlindbitClient;
+pub use blindbit::client::client::NativeBlindbitClient;

From 4b74005adf92ca5d073914b7989c915f359c3570 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Wed, 13 Aug 2025 20:57:17 +0200
Subject: [PATCH 13/15] Minor fixes

---
 src/backend/blindbit/client/structs.rs | 5 ++++-
 src/scanner/mod.rs                     | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/backend/blindbit/client/structs.rs b/src/backend/blindbit/client/structs.rs
index e4c3f13..9495ee2 100644
--- a/src/backend/blindbit/client/structs.rs
+++ b/src/backend/blindbit/client/structs.rs
@@ -76,13 +76,16 @@ pub struct ForwardTxRequest {
     data: String,
 }
 
+// SAFETY: String is Sync, so ForwardTxRequest is also Sync
+unsafe impl Sync for ForwardTxRequest {}
+
 impl ForwardTxRequest {
     pub fn new(tx_hex: String) -> Self {
         Self { data: tx_hex }
     }
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Serialize)]
 pub struct InfoResponse {
     #[serde(deserialize_with = "deserialize_network")]
     pub network: Network,
diff --git a/src/scanner/mod.rs b/src/scanner/mod.rs
index e35437c..e0ca6dd 100644
--- a/src/scanner/mod.rs
+++ b/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;

From 6843598c699e80f1ee948ab61bafda4500a8dfd2 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Wed, 13 Aug 2025 20:58:37 +0200
Subject: [PATCH 14/15] Cargo fmt

---
 examples/lib.rs                         | 37 ++++++++--------
 src/backend/blindbit/backend/backend.rs | 15 ++++---
 src/backend/blindbit/backend/mod.rs     |  4 +-
 src/backend/blindbit/client/client.rs   | 56 ++++++++++++++++++-------
 src/backend/blindbit/mod.rs             |  2 +-
 src/backend/http_client.rs              | 48 ++++++++++++++++-----
 src/client/client.rs                    |  2 +-
 src/lib.rs                              |  2 +-
 src/scanner/mod.rs                      | 41 +++++++++---------
 9 files changed, 129 insertions(+), 78 deletions(-)

diff --git a/examples/lib.rs b/examples/lib.rs
index 4f9cbe4..b665721 100644
--- a/examples/lib.rs
+++ b/examples/lib.rs
@@ -1,10 +1,10 @@
 //! Example of using sp_client in a WASM environment
-//! 
+//!
 //! This example shows how to create a basic silent payment client
 //! and generate receiving addresses in a WASM context.
 
+use bitcoin::{secp256k1::SecretKey, Network};
 use sp_client::{SpClient, SpendKey};
-use bitcoin::{Network, secp256k1::SecretKey};
 
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::*;
@@ -18,7 +18,7 @@ pub fn create_client(scan_key_hex: &str, network: &str) -> Result<String, JsValu
         .map_err(|e| JsValue::from_str(&format!("Invalid scan key: {}", e)))?;
     let scan_sk = SecretKey::from_slice(&scan_key_bytes)
         .map_err(|e| JsValue::from_str(&format!("Invalid secret key: {}", e)))?;
-    
+
     // Parse network
     let network = match network {
         "bitcoin" => Network::Bitcoin,
@@ -27,17 +27,17 @@ pub fn create_client(scan_key_hex: &str, network: &str) -> Result<String, JsValu
         "signet" => Network::Signet,
         _ => return Err(JsValue::from_str("Invalid network")),
     };
-    
+
     // Create spend key (using scan key as spend key for this example)
     let spend_key = SpendKey::Secret(scan_sk);
-    
+
     // Create client
     let client = SpClient::new(scan_sk, spend_key, network)
         .map_err(|e| JsValue::from_str(&format!("Failed to create client: {}", e)))?;
-    
+
     // Get receiving address
     let address = client.get_receiving_address();
-    
+
     Ok(address.to_string())
 }
 
@@ -50,7 +50,7 @@ pub fn get_fingerprint(scan_key_hex: &str, network: &str) -> Result<String, JsVa
         .map_err(|e| JsValue::from_str(&format!("Invalid scan key: {}", e)))?;
     let scan_sk = SecretKey::from_slice(&scan_key_bytes)
         .map_err(|e| JsValue::from_str(&format!("Invalid secret key: {}", e)))?;
-    
+
     // Parse network
     let network = match network {
         "bitcoin" => Network::Bitcoin,
@@ -59,18 +59,19 @@ pub fn get_fingerprint(scan_key_hex: &str, network: &str) -> Result<String, JsVa
         "signet" => Network::Signet,
         _ => return Err(JsValue::from_str("Invalid network")),
     };
-    
+
     // Create spend key (using scan key as spend key for this example)
     let spend_key = SpendKey::Secret(scan_sk);
-    
+
     // Create client
     let client = SpClient::new(scan_sk, spend_key, network)
         .map_err(|e| JsValue::from_str(&format!("Failed to create client: {}", e)))?;
-    
+
     // Get fingerprint
-    let fingerprint = client.get_client_fingerprint()
+    let fingerprint = client
+        .get_client_fingerprint()
         .map_err(|e| JsValue::from_str(&format!("Failed to get fingerprint: {}", e)))?;
-    
+
     Ok(hex::encode(fingerprint))
 }
 
@@ -80,20 +81,20 @@ pub fn create_client_example() -> Result<String, Box<dyn std::error::Error>> {
     // Create a test scan key
     let scan_sk = SecretKey::from_slice(&[0x01; 32])?;
     let spend_key = SpendKey::Secret(scan_sk);
-    
+
     // Create client for testnet
     let client = SpClient::new(scan_sk, spend_key, Network::Testnet)?;
-    
+
     // Get receiving address
     let address = client.get_receiving_address();
-    
+
     Ok(address.to_string())
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    
+
     #[test]
     #[cfg(not(target_arch = "wasm32"))]
     fn test_create_client() {
@@ -102,4 +103,4 @@ mod tests {
         let address = result.unwrap();
         assert!(address.starts_with("sp"));
     }
-} 
\ No newline at end of file
+}
diff --git a/src/backend/blindbit/backend/backend.rs b/src/backend/blindbit/backend/backend.rs
index 2b294d6..0ed95fe 100644
--- a/src/backend/blindbit/backend/backend.rs
+++ b/src/backend/blindbit/backend/backend.rs
@@ -9,9 +9,7 @@ use futures::{stream, Stream, StreamExt};
 
 use anyhow::Result;
 
-use crate::{
-    BlockData, SpentIndexData, UtxoData
-};
+use crate::{BlockData, SpentIndexData, UtxoData};
 
 use crate::backend::blindbit::client::BlindbitClient;
 
@@ -37,7 +35,7 @@ pub struct NativeBlindbitBackend {
 impl NativeBlindbitBackend {
     pub fn new(blindbit_client: NativeBlindbitClient) -> Self {
         Self {
-            client: blindbit_client
+            client: blindbit_client,
         }
     }
 }
@@ -55,7 +53,9 @@ impl ChainBackend for NativeBlindbitBackend {
         dust_limit: Amount,
         with_cutthrough: bool,
     ) -> Pin<Box<dyn Stream<Item = Result<BlockData>> + Send>> {
-        let client = Arc::new(NativeBlindbitClient::new(self.client.host_url().to_string()));
+        let client = Arc::new(NativeBlindbitClient::new(
+            self.client.host_url().to_string(),
+        ));
 
         let res = stream::iter(range)
             .map(move |n| {
@@ -112,12 +112,11 @@ pub struct WasmBlindbitBackend {
 impl WasmBlindbitBackend {
     pub fn new(blindbit_client: WasmBlindbitClient) -> Self {
         Self {
-            client: blindbit_client
+            client: blindbit_client,
         }
     }
 }
 
-
 #[cfg(target_arch = "wasm32")]
 #[async_trait(?Send)]
 impl ChainBackendWasm for WasmBlindbitBackend {
@@ -134,7 +133,7 @@ impl ChainBackendWasm for WasmBlindbitBackend {
         // For WASM, we need to avoid Arc and use a different approach
         // Since WASM doesn't support threading well, we'll use a simpler approach
         let client = self.client.clone();
-        
+
         let res = stream::iter(range)
             .map(move |n| {
                 let client = client.clone();
diff --git a/src/backend/blindbit/backend/mod.rs b/src/backend/blindbit/backend/mod.rs
index eafbc68..1ffae4d 100644
--- a/src/backend/blindbit/backend/mod.rs
+++ b/src/backend/blindbit/backend/mod.rs
@@ -1,6 +1,6 @@
 mod backend;
 
-#[cfg(target_arch = "wasm32")]
-pub use backend::WasmBlindbitBackend;
 #[cfg(not(target_arch = "wasm32"))]
 pub use backend::NativeBlindbitBackend;
+#[cfg(target_arch = "wasm32")]
+pub use backend::WasmBlindbitBackend;
diff --git a/src/backend/blindbit/client/client.rs b/src/backend/blindbit/client/client.rs
index 12e3390..f2f60d0 100644
--- a/src/backend/blindbit/client/client.rs
+++ b/src/backend/blindbit/client/client.rs
@@ -1,17 +1,17 @@
-use bitcoin::{absolute::Height, secp256k1::PublicKey, Amount, Txid};
 use anyhow::Result;
+use bitcoin::{absolute::Height, secp256k1::PublicKey, Amount, Txid};
 
 use crate::backend::http_client::HttpClient;
-#[cfg(target_arch = "wasm32")]
-use crate::backend::http_client::WasmHttpClient;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::backend::http_client::NativeHttpClient;
 #[cfg(target_arch = "wasm32")]
+use crate::backend::http_client::WasmHttpClient;
+#[cfg(target_arch = "wasm32")]
+use std::rc::Rc;
+#[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::*;
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::JsCast;
-#[cfg(target_arch = "wasm32")]
-use std::rc::Rc;
 
 use crate::backend::blindbit::client::structs::InfoResponse;
 
@@ -32,7 +32,12 @@ pub trait BlindbitClient {
     }
 
     async fn tweaks(&self, block_height: Height, dust_limit: Amount) -> Result<Vec<PublicKey>> {
-        let url = format!("{}tweaks/{}?dustLimit={}", self.host_url(), block_height, dust_limit.to_sat());
+        let url = format!(
+            "{}tweaks/{}?dustLimit={}",
+            self.host_url(),
+            block_height,
+            dust_limit.to_sat()
+        );
         Ok(self.http_client().get(&url).await?)
     }
 
@@ -41,7 +46,12 @@ pub trait BlindbitClient {
         block_height: Height,
         dust_limit: Amount,
     ) -> Result<Vec<PublicKey>> {
-        let url = format!("{}tweak-index/{}?dustLimit={}", self.host_url(), block_height, dust_limit.to_sat());
+        let url = format!(
+            "{}tweak-index/{}?dustLimit={}",
+            self.host_url(),
+            block_height,
+            dust_limit.to_sat()
+        );
         Ok(self.http_client().get(&url).await?)
     }
 
@@ -87,7 +97,7 @@ pub struct NativeBlindbitClient {
 impl NativeBlindbitClient {
     pub fn new(host_url: String) -> Self {
         let mut host_url = host_url;
-        
+
         // we need a trailing slash, if not present we append it
         if !host_url.ends_with('/') {
             host_url.push('/');
@@ -95,7 +105,10 @@ impl NativeBlindbitClient {
 
         let http_client = NativeHttpClient::new();
 
-        Self { http_client, host_url }
+        Self {
+            http_client,
+            host_url,
+        }
     }
 
     pub fn host_url(&self) -> &str {
@@ -111,8 +124,12 @@ impl NativeBlindbitClient {
 impl BlindbitClient for NativeBlindbitClient {
     type Client = NativeHttpClient;
 
-    fn host_url(&self) -> &str { &self.host_url }
-    fn http_client(&self) -> &Self::Client { &self.http_client }
+    fn host_url(&self) -> &str {
+        &self.host_url
+    }
+    fn http_client(&self) -> &Self::Client {
+        &self.http_client
+    }
 }
 
 #[cfg(target_arch = "wasm32")]
@@ -125,7 +142,9 @@ pub struct WasmBlindbitClient {
 
 #[cfg(target_arch = "wasm32")]
 impl WasmBlindbitClient {
-    pub fn http_client(&self) -> &WasmHttpClient { self.http_client.as_ref() }
+    pub fn http_client(&self) -> &WasmHttpClient {
+        self.http_client.as_ref()
+    }
 }
 #[cfg(target_arch = "wasm32")]
 #[wasm_bindgen]
@@ -136,7 +155,10 @@ impl WasmBlindbitClient {
             wasm_bindgen::throw_str("Failed to convert to JsHttpClient");
         });
         let wasm_client = WasmHttpClient::new(js_client);
-        Self { http_client: Rc::new(wasm_client), host_url }
+        Self {
+            http_client: Rc::new(wasm_client),
+            host_url,
+        }
     }
 }
 
@@ -144,6 +166,10 @@ impl WasmBlindbitClient {
 impl BlindbitClient for WasmBlindbitClient {
     type Client = WasmHttpClient;
 
-    fn host_url(&self) -> &str { &self.host_url }
-    fn http_client(&self) -> &Self::Client { self.http_client.as_ref() }
+    fn host_url(&self) -> &str {
+        &self.host_url
+    }
+    fn http_client(&self) -> &Self::Client {
+        self.http_client.as_ref()
+    }
 }
diff --git a/src/backend/blindbit/mod.rs b/src/backend/blindbit/mod.rs
index c17ad9e..cd8074d 100644
--- a/src/backend/blindbit/mod.rs
+++ b/src/backend/blindbit/mod.rs
@@ -11,4 +11,4 @@ pub use backend::NativeBlindbitBackend;
 pub use client::WasmBlindbitClient;
 
 #[cfg(not(target_arch = "wasm32"))]
-pub use client::NativeBlindbitClient;
\ No newline at end of file
+pub use client::NativeBlindbitClient;
diff --git a/src/backend/http_client.rs b/src/backend/http_client.rs
index 7e732c2..9c4c992 100644
--- a/src/backend/http_client.rs
+++ b/src/backend/http_client.rs
@@ -1,5 +1,5 @@
-use async_trait::async_trait;
 use anyhow::Result;
+use async_trait::async_trait;
 use serde::{de::DeserializeOwned, Serialize};
 
 // Define the trait differently for WASM vs native
@@ -7,14 +7,22 @@ use serde::{de::DeserializeOwned, Serialize};
 #[async_trait]
 pub trait HttpClient {
     async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T>;
-    async fn post<T: DeserializeOwned>(&self, url: &str, body: &(impl Serialize + Sync)) -> Result<T>;
+    async fn post<T: DeserializeOwned>(
+        &self,
+        url: &str,
+        body: &(impl Serialize + Sync),
+    ) -> Result<T>;
 }
 
 #[cfg(target_arch = "wasm32")]
 #[async_trait(?Send)]
 pub trait HttpClient {
     async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T>;
-    async fn post<T: DeserializeOwned>(&self, url: &str, body: &(impl Serialize + Sync)) -> Result<T>;
+    async fn post<T: DeserializeOwned>(
+        &self,
+        url: &str,
+        body: &(impl Serialize + Sync),
+    ) -> Result<T>;
 }
 
 // Native implementation using reqwest
@@ -42,19 +50,23 @@ impl HttpClient for NativeHttpClient {
         Ok(serde_json::from_str(&text)?)
     }
 
-    async fn post<T: DeserializeOwned>(&self, url: &str, body: &(impl Serialize + Sync)) -> Result<T> {
+    async fn post<T: DeserializeOwned>(
+        &self,
+        url: &str,
+        body: &(impl Serialize + Sync),
+    ) -> Result<T> {
         let response = self.client.post(url).json(body).send().await?;
         let text: String = response.text().await?;
         Ok(serde_json::from_str(&text)?)
     }
 }
 
+#[cfg(target_arch = "wasm32")]
+use js_sys::Promise;
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::*;
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen_futures::JsFuture;
-#[cfg(target_arch = "wasm32")]
-use js_sys::Promise;
 
 #[cfg(target_arch = "wasm32")]
 #[wasm_bindgen]
@@ -84,18 +96,32 @@ impl WasmHttpClient {
 #[async_trait::async_trait(?Send)]
 impl HttpClient for WasmHttpClient {
     async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T> {
-        let p = self.inner.get(url).map_err(|e| anyhow::anyhow!("get() threw: {:?}", e))?;
-        let v = JsFuture::from(p).await.map_err(|e| anyhow::anyhow!("promise rejected: {:?}", e))?;
+        let p = self
+            .inner
+            .get(url)
+            .map_err(|e| anyhow::anyhow!("get() threw: {:?}", e))?;
+        let v = JsFuture::from(p)
+            .await
+            .map_err(|e| anyhow::anyhow!("promise rejected: {:?}", e))?;
         let t: T = serde_wasm_bindgen::from_value(v)
             .map_err(|e| anyhow::anyhow!("deserialize error: {}", e))?;
         Ok(t)
     }
 
-    async fn post<T: DeserializeOwned>(&self, url: &str, body: &(impl Serialize + Sync)) -> Result<T> {
+    async fn post<T: DeserializeOwned>(
+        &self,
+        url: &str,
+        body: &(impl Serialize + Sync),
+    ) -> Result<T> {
         let body_js = serde_wasm_bindgen::to_value(body)
             .map_err(|e| anyhow::anyhow!("serialize body error: {}", e))?;
-        let p = self.inner.post(url, &body_js).map_err(|e| anyhow::anyhow!("post() threw: {:?}", e))?;
-        let v = JsFuture::from(p).await.map_err(|e| anyhow::anyhow!("promise rejected: {:?}", e))?;
+        let p = self
+            .inner
+            .post(url, &body_js)
+            .map_err(|e| anyhow::anyhow!("post() threw: {:?}", e))?;
+        let v = JsFuture::from(p)
+            .await
+            .map_err(|e| anyhow::anyhow!("promise rejected: {:?}", e))?;
         let t: T = serde_wasm_bindgen::from_value(v)
             .map_err(|e| anyhow::anyhow!("deserialize error: {}", e))?;
         Ok(t)
diff --git a/src/client/client.rs b/src/client/client.rs
index e80b793..b980af6 100644
--- a/src/client/client.rs
+++ b/src/client/client.rs
@@ -113,7 +113,7 @@ impl SpClient {
         #[cfg(not(target_arch = "wasm32"))]
         {
             use rayon::prelude::*;
-            
+
             let shared_secrets: Vec<PublicKey> = tweak_data_vec
                 .into_par_iter()
                 .map(|tweak| sp_utils::receiving::calculate_ecdh_shared_secret(&tweak, b_scan))
diff --git a/src/lib.rs b/src/lib.rs
index 2e27d2b..88373dd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,8 +6,8 @@ mod updater;
 
 pub use bdk_coin_select::FeeRate;
 pub use bitcoin;
-pub use silentpayments;
 pub use futures;
+pub use silentpayments;
 
 pub use backend::*;
 pub use client::*;
diff --git a/src/scanner/mod.rs b/src/scanner/mod.rs
index e0ca6dd..f53a47e 100644
--- a/src/scanner/mod.rs
+++ b/src/scanner/mod.rs
@@ -2,8 +2,7 @@ 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;
@@ -21,14 +20,14 @@ use crate::backend::ChainBackend;
 use crate::backend::ChainBackendWasm;
 
 /// 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)
@@ -43,10 +42,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(
@@ -55,12 +54,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(
@@ -71,11 +70,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(
@@ -85,12 +84,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(
@@ -101,7 +100,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;
@@ -110,7 +109,7 @@ pub trait SpScanner {
     fn save_state(&mut self) -> Result<()>;
 
     /// Record found outputs for a block
-    /// 
+    ///
     /// # Arguments
     /// * `height` - Block height
     /// * `block_hash` - Block hash
@@ -123,7 +122,7 @@ pub trait SpScanner {
     ) -> Result<()>;
 
     /// Record spent inputs for a block
-    /// 
+    ///
     /// # Arguments
     /// * `height` - Block height
     /// * `block_hash` - Block hash
@@ -136,7 +135,7 @@ pub trait SpScanner {
     ) -> Result<()>;
 
     /// Record scan progress
-    /// 
+    ///
     /// # Arguments
     /// * `start` - Start height
     /// * `current` - Current height
@@ -160,7 +159,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,
@@ -217,7 +216,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,
@@ -293,7 +292,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,
@@ -315,7 +314,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();
@@ -326,7 +325,7 @@ pub trait SpScanner {
     }
 
     /// Check if block contains relevant input transactions
-    /// 
+    ///
     /// This is a default implementation that can be overridden if needed
     fn check_block_inputs(
         &self,

From d1598be08f3fba1604fd84d664b0dbc6d83dfdc8 Mon Sep 17 00:00:00 2001
From: Sosthene <contact@sosthene.net>
Date: Mon, 18 Aug 2025 10:45:47 +0200
Subject: [PATCH 15/15] WIP

---
 Cargo.toml                                    |  29 +-
 README.md                                     |  39 ++-
 examples/README.md                            | 169 +++++++++++
 examples/http-client.ts                       | 105 +++++++
 examples/lib.rs                               |  10 +-
 examples/package.json                         |  29 ++
 examples/test-wasm.js                         |  95 +++++++
 src/backend/blindbit/backend/backend.rs       | 181 ------------
 src/backend/blindbit/backend/mod.rs           |  10 +-
 src/backend/blindbit/backend/native.rs        |  91 ++++++
 src/backend/blindbit/backend/wasm.rs          |  85 ++++++
 src/backend/blindbit/client/client.rs         | 175 ------------
 src/backend/blindbit/client/mod.rs            |  13 +-
 src/backend/blindbit/client/native.rs         | 102 +++++++
 src/backend/blindbit/client/wasm.rs           | 100 +++++++
 src/backend/blindbit/mod.rs                   |  12 -
 src/backend/{backend.rs => chain_backend.rs}  |   4 +-
 src/backend/http_client/mod.rs                |   8 +
 src/backend/http_client/native.rs             |  46 +++
 .../{http_client.rs => http_client/wasm.rs}   |  73 +----
 src/backend/mod.rs                            |  33 +--
 src/client/client.rs                          |  48 ++--
 src/scanner/mod.rs                            | 268 ++++++++----------
 23 files changed, 1054 insertions(+), 671 deletions(-)
 create mode 100644 examples/README.md
 create mode 100644 examples/http-client.ts
 create mode 100644 examples/package.json
 create mode 100644 examples/test-wasm.js
 delete mode 100644 src/backend/blindbit/backend/backend.rs
 create mode 100644 src/backend/blindbit/backend/native.rs
 create mode 100644 src/backend/blindbit/backend/wasm.rs
 delete mode 100644 src/backend/blindbit/client/client.rs
 create mode 100644 src/backend/blindbit/client/native.rs
 create mode 100644 src/backend/blindbit/client/wasm.rs
 rename src/backend/{backend.rs => chain_backend.rs} (91%)
 create mode 100644 src/backend/http_client/mod.rs
 create mode 100644 src/backend/http_client/native.rs
 rename src/backend/{http_client.rs => http_client/wasm.rs} (53%)

diff --git a/Cargo.toml b/Cargo.toml
index 4b219b4..c811b2a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,10 +6,6 @@ edition = "2021"
 [lib]
 name = "sp_client"
 
-[target.'cfg(target_arch = "wasm32")'.lib]
-crate-type = ["cdylib", "rlib"]
-
-[target.'cfg(not(target_arch = "wasm32"))'.lib]
 crate-type = ["lib", "staticlib", "cdylib", "rlib"]
 
 [dependencies]
@@ -21,29 +17,20 @@ bitcoin = { version = "0.31.1", features = ["serde", "rand", "base64"] }
 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 }
 
-# WASM-specific dependencies
 wasm-bindgen = { version = "0.2", optional = true }
 
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-rayon = "1.10.0"
-reqwest = { version = "0.12.4", features = ["rustls-tls", "gzip", "json"], default-features = false }
+reqwest = { version = "0.12.4", features = ["rustls-tls", "gzip", "json"], default-features = false, optional = true }
 
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-wasm-bindgen = "0.2"
-js-sys = "0.3"
-wasm-bindgen-futures = "0.4"
-serde-wasm-bindgen = "0.6.5"
+js-sys = { version = "0.3", optional = true }
+wasm-bindgen-futures = { version = "0.4", optional = true }
+serde-wasm-bindgen = { version = "0.6.5", optional = true }
 
 [features]
-blindbit-backend = ["reqwest", "hex"]
-default = []
-
-# WASM-specific features
-wasm = ["wasm-bindgen"]
+blindbit-native = ["reqwest", "rayon"]
+blindbit-wasm = ["wasm-bindgen", "js-sys", "wasm-bindgen-futures", "serde-wasm-bindgen"]
+default = ["blindbit-native"]
diff --git a/README.md b/README.md
index bc06c45..1963e82 100644
--- a/README.md
+++ b/README.md
@@ -40,9 +40,44 @@ wasm-pack build --target web
 
 When building for WASM:
 - The `rayon` dependency is automatically disabled and parallel processing falls back to sequential processing
-- The `blindbit-backend` feature is available but requires appropriate HTTP client configuration for WASM
+- The `blindbit-backend` feature is available with **TypeScript HTTP client injection** for WASM
 - All core functionality remains available
 
+### HTTP Client in WASM
+
+The library uses a **TypeScript HTTP client injection** approach for WASM builds:
+
+- **Native builds**: Use `reqwest` for HTTP requests
+- **WASM builds**: Accept a TypeScript HTTP client that implements the required interface
+
+This approach provides several benefits:
+- **No bundle bloat**: TypeScript code doesn't increase WASM bundle size
+- **Familiar APIs**: Use standard `fetch()` API
+- **Better error handling**: TypeScript gives proper error types
+- **Flexibility**: Easy to add features like retry logic, caching, etc.
+
 ### Usage in Web Applications
 
-The library can be used in web applications through standard WASM interop. Note that some features like the `blindbit-backend` may require additional configuration for HTTP requests in the browser environment.
+The library can be used in web applications through standard WASM interop. For HTTP functionality in WASM:
+
+```typescript
+import { WasmHttpClient } from './http-client';
+import init, { BlindbitClient } from './pkg/sp_client';
+
+async function main() {
+  await init();
+  
+  const httpClient = new WasmHttpClient();
+  const blindbitClient = BlindbitClient.new_wasm(
+    "https://api.example.com/", 
+    httpClient
+  );
+  
+  const height = await blindbitClient.block_height_wasm();
+  console.log('Block height:', height);
+}
+
+main();
+```
+
+See the `examples/` directory for complete working examples and the `http-client.ts` file for the TypeScript HTTP client implementation.
diff --git a/examples/README.md b/examples/README.md
new file mode 100644
index 0000000..d8a830c
--- /dev/null
+++ b/examples/README.md
@@ -0,0 +1,169 @@
+# Using SP Client with TypeScript HTTP Client in WASM
+
+This example demonstrates how to use the SP Client library in a WASM environment with a TypeScript HTTP client instead of the native `reqwest` client.
+
+## Overview
+
+The library now supports both native and WASM environments:
+- **Native**: Uses `reqwest` for HTTP requests
+- **WASM**: Uses a TypeScript HTTP client passed from JavaScript
+
+## Setup
+
+### 1. Build for WASM
+
+```bash
+# Install WASM target
+rustup target add wasm32-unknown-unknown
+
+# Build the library
+cargo build --target wasm32-unknown-unknown
+
+# Or use wasm-pack for easier builds
+wasm-pack build --target web
+```
+
+### 2. TypeScript HTTP Client
+
+The `http-client.ts` file provides a TypeScript implementation of the HTTP client interface expected by the WASM code.
+
+## Usage
+
+### Basic Example
+
+```typescript
+import { WasmHttpClient } from './http-client';
+import init, { BlindbitClient } from './pkg/sp_client';
+
+async function main() {
+  // Initialize WASM
+  await init();
+  
+  // Create HTTP client
+  const httpClient = new WasmHttpClient();
+  
+  // Create Blindbit client with HTTP client
+  const blindbitClient = BlindbitClient.new_wasm(
+    "https://api.example.com/", 
+    httpClient
+  );
+  
+  // Use the client
+  try {
+    const height = await blindbitClient.block_height_wasm();
+    console.log('Block height:', height);
+    
+    const info = await blindbitClient.info_wasm();
+    console.log('Info:', info);
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+
+main();
+```
+
+### Advanced Example with Error Handling
+
+```typescript
+import { WasmHttpClient } from './http-client';
+import init, { BlindbitClient } from './pkg/sp_client';
+
+class BlindbitService {
+  private client: BlindbitClient;
+  
+  constructor(apiUrl: string) {
+    this.client = BlindbitClient.new_wasm(apiUrl, new WasmHttpClient());
+  }
+  
+  async getBlockHeight(): Promise<number> {
+    try {
+      return await this.client.block_height_wasm();
+    } catch (error) {
+      console.error('Failed to get block height:', error);
+      throw new Error(`Block height request failed: ${error}`);
+    }
+  }
+  
+  async getInfo(): Promise<any> {
+    try {
+      const infoJson = await this.client.info_wasm();
+      return JSON.parse(infoJson);
+    } catch (error) {
+      console.error('Failed to get info:', error);
+      throw new Error(`Info request failed: ${error}`);
+    }
+  }
+}
+
+// Usage
+async function main() {
+  await init();
+  
+  const service = new BlindbitService("https://api.example.com/");
+  
+  try {
+    const [height, info] = await Promise.all([
+      service.getBlockHeight(),
+      service.getInfo()
+    ]);
+    
+    console.log(`Current block height: ${height}`);
+    console.log('API info:', info);
+  } catch (error) {
+    console.error('Service error:', error);
+  }
+}
+
+main();
+```
+
+## Architecture
+
+### How It Works
+
+1. **TypeScript HTTP Client**: Implements the interface expected by Rust WASM code
+2. **WASM Bindings**: Rust code exposes methods that can be called from JavaScript
+3. **HTTP Client Injection**: The TypeScript client is passed to the Rust code during construction
+4. **Request Delegation**: Rust code delegates HTTP requests to the injected TypeScript client
+
+### Benefits
+
+- **No Bundle Bloat**: TypeScript code doesn't increase WASM bundle size
+- **Familiar APIs**: Use standard `fetch()` API
+- **Better Error Handling**: TypeScript gives proper error types
+- **Flexibility**: Easy to add features like retry logic, caching, etc.
+- **Performance**: No overhead from Rust-to-JS conversions for HTTP operations
+
+### Trade-offs
+
+- **Complexity**: Need to handle JS interop and type conversions
+- **Memory Management**: Careful about JS object lifetimes
+- **Error Propagation**: Errors cross Rust/JS boundary
+- **Type Safety**: Less compile-time safety for HTTP operations
+
+## Troubleshooting
+
+### Common Issues
+
+1. **WASM not initialized**: Make sure to call `await init()` before using the library
+2. **HTTP client not passed**: Use `new_wasm()` constructor for WASM builds
+3. **CORS issues**: Ensure your API server allows requests from your domain
+4. **Type errors**: Make sure TypeScript types match the expected interface
+
+### Debug Tips
+
+- Check browser console for JavaScript errors
+- Use browser dev tools to inspect network requests
+- Verify WASM module is loaded correctly
+- Test HTTP client independently before integrating with WASM
+
+## Next Steps
+
+- Add retry logic to the HTTP client
+- Implement request caching
+- Add request/response interceptors
+- Support for different authentication methods
+- Add request timeout handling
+
+
diff --git a/examples/http-client.ts b/examples/http-client.ts
new file mode 100644
index 0000000..46e6cd8
--- /dev/null
+++ b/examples/http-client.ts
@@ -0,0 +1,105 @@
+/**
+ * TypeScript HTTP client for use with WASM code
+ * This client implements the interface expected by the Rust WASM code
+ */
+
+export class WasmHttpClient {
+  private baseUrl?: string;
+
+  constructor(baseUrl?: string) {
+    this.baseUrl = baseUrl;
+  }
+
+  /**
+   * Make a GET request
+   */
+  async get<T>(url: string): Promise<T> {
+    const fullUrl = this.baseUrl ? `${this.baseUrl}${url}` : url;
+    
+    try {
+      const response = await fetch(fullUrl, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error('GET request failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Make a POST request
+   */
+  async post<T>(url: string, body: any): Promise<T> {
+    const fullUrl = this.baseUrl ? `${this.baseUrl}${url}` : url;
+    
+    try {
+      const response = await fetch(fullUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error('POST request failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Set a base URL for all requests
+   */
+  setBaseUrl(baseUrl: string) {
+    this.baseUrl = baseUrl;
+  }
+}
+
+/**
+ * Example usage with the WASM code:
+ * 
+ * ```typescript
+ * import { WasmHttpClient } from './http-client';
+ * import init, { BlindbitClient } from './pkg/sp_client';
+ * 
+ * async function main() {
+ *   // Initialize WASM
+ *   await init();
+ *   
+ *   // Create HTTP client
+ *   const httpClient = new WasmHttpClient();
+ *   
+ *   // Create Blindbit client with HTTP client
+ *   const blindbitClient = BlindbitClient.new_wasm(
+ *     "https://api.example.com/", 
+ *     httpClient
+ *   );
+ *   
+ *   // Use the client
+ *   try {
+ *     const height = await blindbitClient.block_height_wasm();
+ *     console.log('Block height:', height);
+ *   } catch (error) {
+ *     console.error('Error:', error);
+ *   }
+ * }
+ * 
+ * main();
+ * ```
+ */
+
+
diff --git a/examples/lib.rs b/examples/lib.rs
index b665721..1efca90 100644
--- a/examples/lib.rs
+++ b/examples/lib.rs
@@ -6,11 +6,11 @@
 use bitcoin::{secp256k1::SecretKey, Network};
 use sp_client::{SpClient, SpendKey};
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(feature = "blindbit-wasm")]
 use wasm_bindgen::prelude::*;
 
 /// Create a new silent payment client for WASM
-#[cfg(target_arch = "wasm32")]
+#[cfg(feature = "blindbit-wasm")]
 #[wasm_bindgen]
 pub fn create_client(scan_key_hex: &str, network: &str) -> Result<String, JsValue> {
     // Parse the scan key
@@ -42,7 +42,7 @@ pub fn create_client(scan_key_hex: &str, network: &str) -> Result<String, JsValu
 }
 
 /// Get client fingerprint for WASM
-#[cfg(target_arch = "wasm32")]
+#[cfg(feature = "blindbit-wasm")]
 #[wasm_bindgen]
 pub fn get_fingerprint(scan_key_hex: &str, network: &str) -> Result<String, JsValue> {
     // Parse the scan key
@@ -76,7 +76,7 @@ pub fn get_fingerprint(scan_key_hex: &str, network: &str) -> Result<String, JsVa
 }
 
 // Non-WASM example for testing
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(feature = "blindbit-native")]
 pub fn create_client_example() -> Result<String, Box<dyn std::error::Error>> {
     // Create a test scan key
     let scan_sk = SecretKey::from_slice(&[0x01; 32])?;
@@ -96,7 +96,7 @@ mod tests {
     use super::*;
 
     #[test]
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(feature = "blindbit-native")]
     fn test_create_client() {
         let result = create_client_example();
         assert!(result.is_ok());
diff --git a/examples/package.json b/examples/package.json
new file mode 100644
index 0000000..8f76f8f
--- /dev/null
+++ b/examples/package.json
@@ -0,0 +1,29 @@
+{
+  "name": "sp-client-examples",
+  "version": "1.0.0",
+  "description": "Examples for using SP Client with TypeScript HTTP client in WASM",
+  "main": "test-wasm.js",
+  "scripts": {
+    "test": "node test-wasm.js",
+    "build": "cd .. && wasm-pack build --target web",
+    "dev": "cd .. && wasm-pack build --target web --dev"
+  },
+  "keywords": [
+    "wasm",
+    "rust",
+    "bitcoin",
+    "silent-payments",
+    "http-client"
+  ],
+  "author": "SP Client Team",
+  "license": "MIT",
+  "devDependencies": {
+    "wasm-pack": "^0.12.0"
+  },
+  "dependencies": {},
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}
+
+
diff --git a/examples/test-wasm.js b/examples/test-wasm.js
new file mode 100644
index 0000000..5ff6bb6
--- /dev/null
+++ b/examples/test-wasm.js
@@ -0,0 +1,95 @@
+/**
+ * Simple test file to demonstrate WASM integration
+ * Run this in a browser environment after building with wasm-pack
+ */
+
+// Mock HTTP client for testing
+class MockHttpClient {
+  constructor() {
+    this.calls = [];
+  }
+
+  async get(url) {
+    this.calls.push({ method: 'GET', url });
+    
+    // Mock responses based on URL
+    if (url.includes('block-height')) {
+      return { block_height: 800000 };
+    } else if (url.includes('info')) {
+      return { 
+        network: 'bitcoin',
+        height: 800000,
+        tweaks_only: true,
+        tweaks_full_basic: true,
+        tweaks_full_with_dust_filter: true,
+        tweaks_cut_through_with_dust_filter: true
+      };
+    }
+    
+    throw new Error(`Unknown endpoint: ${url}`);
+  }
+
+  async post(url, body) {
+    this.calls.push({ method: 'POST', url, body });
+    
+    if (url.includes('forward-tx')) {
+      return 'mock-txid-1234567890abcdef';
+    }
+    
+    throw new Error(`Unknown endpoint: ${url}`);
+  }
+
+  getCallHistory() {
+    return this.calls;
+  }
+}
+
+// Test function
+async function testWasmIntegration() {
+  try {
+    console.log('Testing WASM integration...');
+    
+    // Create mock HTTP client
+    const httpClient = new MockHttpClient();
+    
+    // Note: In a real environment, you would:
+    // 1. Import the WASM module: import init, { BlindbitClient } from './pkg/sp_client';
+    // 2. Initialize WASM: await init();
+    // 3. Create the client: const client = BlindbitClient.new_wasm("https://api.example.com/", httpClient);
+    
+    console.log('Mock HTTP client created');
+    console.log('HTTP client methods:', Object.getOwnPropertyNames(Object.getPrototypeOf(httpClient)));
+    
+    // Test GET request
+    const heightResponse = await httpClient.get('block-height');
+    console.log('Block height response:', heightResponse);
+    
+    // Test POST request
+    const txResponse = await httpClient.post('forward-tx', { data: 'mock-tx-hex' });
+    console.log('Transaction response:', txResponse);
+    
+    // Show call history
+    console.log('HTTP call history:', httpClient.getCallHistory());
+    
+    console.log('✅ All tests passed!');
+    
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+  }
+}
+
+// Export for use in other modules
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { MockHttpClient, testWasmIntegration };
+} else {
+  // Browser environment
+  window.MockHttpClient = MockHttpClient;
+  window.testWasmIntegration = testWasmIntegration;
+}
+
+// Auto-run in browser
+if (typeof window !== 'undefined') {
+  testWasmIntegration();
+}
+
+
diff --git a/src/backend/blindbit/backend/backend.rs b/src/backend/blindbit/backend/backend.rs
deleted file mode 100644
index 0ed95fe..0000000
--- a/src/backend/blindbit/backend/backend.rs
+++ /dev/null
@@ -1,181 +0,0 @@
-use std::{ops::RangeInclusive, pin::Pin};
-
-#[cfg(not(target_arch = "wasm32"))]
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use bitcoin::{absolute::Height, Amount};
-use futures::{stream, Stream, StreamExt};
-
-use anyhow::Result;
-
-use crate::{BlockData, SpentIndexData, UtxoData};
-
-use crate::backend::blindbit::client::BlindbitClient;
-
-#[cfg(not(target_arch = "wasm32"))]
-use crate::backend::blindbit::client::NativeBlindbitClient;
-#[cfg(target_arch = "wasm32")]
-use crate::backend::blindbit::client::WasmBlindbitClient;
-
-#[cfg(not(target_arch = "wasm32"))]
-use crate::backend::ChainBackend;
-
-#[cfg(target_arch = "wasm32")]
-use crate::backend::ChainBackendWasm;
-
-const CONCURRENT_FILTER_REQUESTS: usize = 200;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub struct NativeBlindbitBackend {
-    client: NativeBlindbitClient,
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl NativeBlindbitBackend {
-    pub fn new(blindbit_client: NativeBlindbitClient) -> Self {
-        Self {
-            client: blindbit_client,
-        }
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-#[async_trait]
-impl ChainBackend for NativeBlindbitBackend {
-    /// 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>> + Send>> {
-        let client = Arc::new(NativeBlindbitClient::new(
-            self.client.host_url().to_string(),
-        ));
-
-        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
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-pub struct WasmBlindbitBackend {
-    client: WasmBlindbitClient,
-}
-
-#[cfg(target_arch = "wasm32")]
-impl WasmBlindbitBackend {
-    pub fn new(blindbit_client: WasmBlindbitClient) -> Self {
-        Self {
-            client: blindbit_client,
-        }
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-#[async_trait(?Send)]
-impl ChainBackendWasm for WasmBlindbitBackend {
-    /// 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>>>> {
-        // For WASM, we need to avoid Arc and use a different approach
-        // Since WASM doesn't support threading well, we'll use a simpler approach
-        let client = 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(1); // Use buffered(1) for WASM to avoid concurrency issues
-
-        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/src/backend/blindbit/backend/mod.rs b/src/backend/blindbit/backend/mod.rs
index 1ffae4d..e30a026 100644
--- a/src/backend/blindbit/backend/mod.rs
+++ b/src/backend/blindbit/backend/mod.rs
@@ -1,6 +1,4 @@
-mod backend;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub use backend::NativeBlindbitBackend;
-#[cfg(target_arch = "wasm32")]
-pub use backend::WasmBlindbitBackend;
+#[cfg(all(feature = "blindbit-native", not(target_arch = "wasm32")))]
+pub mod native;
+#[cfg(all(feature = "blindbit-wasm", target_arch = "wasm32"))]
+pub mod wasm;
diff --git a/src/backend/blindbit/backend/native.rs b/src/backend/blindbit/backend/native.rs
new file mode 100644
index 0000000..a93f433
--- /dev/null
+++ b/src/backend/blindbit/backend/native.rs
@@ -0,0 +1,91 @@
+use std::{ops::RangeInclusive, pin::Pin};
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use bitcoin::{absolute::Height, Amount};
+use futures::{stream, Stream, StreamExt};
+
+use anyhow::Result;
+
+use crate::{BlockData, SpentIndexData, UtxoData};
+
+use crate::backend::blindbit::client::native::NativeBlindbitClient;
+
+use crate::backend::ChainBackend;
+
+const CONCURRENT_FILTER_REQUESTS: usize = 200;
+
+pub struct NativeBlindbitBackend {
+    client: NativeBlindbitClient,
+}
+
+impl NativeBlindbitBackend {
+    pub fn new(blindbit_client: NativeBlindbitClient) -> Self {
+        Self {
+            client: blindbit_client,
+        }
+    }
+}
+
+#[async_trait]
+impl ChainBackend for NativeBlindbitBackend {
+    /// 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>> + Send>> {
+        let client = Arc::new(NativeBlindbitClient::new(
+            self.client.host_url().to_string(),
+        ));
+
+        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/src/backend/blindbit/backend/wasm.rs b/src/backend/blindbit/backend/wasm.rs
new file mode 100644
index 0000000..b78b4c6
--- /dev/null
+++ b/src/backend/blindbit/backend/wasm.rs
@@ -0,0 +1,85 @@
+use std::{ops::RangeInclusive, pin::Pin};
+
+use async_trait::async_trait;
+use bitcoin::{absolute::Height, Amount};
+use futures::{stream, Stream, StreamExt};
+
+use anyhow::Result;
+
+use crate::{BlockData, SpentIndexData, UtxoData};
+
+use crate::backend::blindbit::client::wasm::WasmBlindbitClient;
+
+use crate::backend::ChainBackendWasm;
+
+pub struct WasmBlindbitBackend {
+    client: WasmBlindbitClient,
+}
+
+impl WasmBlindbitBackend {
+    pub fn new(blindbit_client: WasmBlindbitClient) -> Self {
+        Self {
+            client: blindbit_client,
+        }
+    }
+}
+
+#[async_trait(?Send)]
+impl ChainBackendWasm for WasmBlindbitBackend {
+    /// 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 = 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(1); // Use buffered(1) for WASM to avoid concurrency issues
+
+        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/src/backend/blindbit/client/client.rs b/src/backend/blindbit/client/client.rs
deleted file mode 100644
index f2f60d0..0000000
--- a/src/backend/blindbit/client/client.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-use anyhow::Result;
-use bitcoin::{absolute::Height, secp256k1::PublicKey, Amount, Txid};
-
-use crate::backend::http_client::HttpClient;
-#[cfg(not(target_arch = "wasm32"))]
-use crate::backend::http_client::NativeHttpClient;
-#[cfg(target_arch = "wasm32")]
-use crate::backend::http_client::WasmHttpClient;
-#[cfg(target_arch = "wasm32")]
-use std::rc::Rc;
-#[cfg(target_arch = "wasm32")]
-use wasm_bindgen::prelude::*;
-#[cfg(target_arch = "wasm32")]
-use wasm_bindgen::JsCast;
-
-use crate::backend::blindbit::client::structs::InfoResponse;
-
-use super::structs::{
-    BlockHeightResponse, FilterResponse, ForwardTxRequest, SpentIndexResponse, UtxoResponse,
-};
-
-pub trait BlindbitClient {
-    type Client: HttpClient;
-
-    fn host_url(&self) -> &str;
-    fn http_client(&self) -> &Self::Client;
-
-    async fn block_height(&self) -> Result<Height> {
-        let url = format!("{}block-height", self.host_url());
-        let blkheight: BlockHeightResponse = self.http_client().get(&url).await?;
-        Ok(blkheight.block_height)
-    }
-
-    async fn tweaks(&self, block_height: Height, dust_limit: Amount) -> Result<Vec<PublicKey>> {
-        let url = format!(
-            "{}tweaks/{}?dustLimit={}",
-            self.host_url(),
-            block_height,
-            dust_limit.to_sat()
-        );
-        Ok(self.http_client().get(&url).await?)
-    }
-
-    async fn tweak_index(
-        &self,
-        block_height: Height,
-        dust_limit: Amount,
-    ) -> Result<Vec<PublicKey>> {
-        let url = format!(
-            "{}tweak-index/{}?dustLimit={}",
-            self.host_url(),
-            block_height,
-            dust_limit.to_sat()
-        );
-        Ok(self.http_client().get(&url).await?)
-    }
-
-    async fn utxos(&self, block_height: Height) -> Result<Vec<UtxoResponse>> {
-        let url = format!("{}utxos/{}", self.host_url(), block_height);
-        Ok(self.http_client().get(&url).await?)
-    }
-
-    async fn spent_index(&self, block_height: Height) -> Result<SpentIndexResponse> {
-        let url = format!("{}spent-index/{}", self.host_url(), block_height);
-        Ok(self.http_client().get(&url).await?)
-    }
-
-    async fn filter_new_utxos(&self, block_height: Height) -> Result<FilterResponse> {
-        let url = format!("{}filter/new-utxos/{}", self.host_url(), block_height);
-        Ok(self.http_client().get(&url).await?)
-    }
-
-    async fn filter_spent(&self, block_height: Height) -> Result<FilterResponse> {
-        let url = format!("{}filter/spent/{}", self.host_url(), block_height);
-        Ok(self.http_client().get(&url).await?)
-    }
-
-    async fn forward_tx(&self, tx_hex: String) -> Result<Txid> {
-        let url = format!("{}forward-tx", self.host_url());
-        let body = ForwardTxRequest::new(tx_hex);
-        Ok(self.http_client().post(&url, &body).await?)
-    }
-
-    async fn info(&self) -> Result<InfoResponse> {
-        let url = format!("{}info", self.host_url());
-        Ok(self.http_client().get(&url).await?)
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub struct NativeBlindbitClient {
-    http_client: NativeHttpClient,
-    host_url: String,
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl NativeBlindbitClient {
-    pub fn new(host_url: String) -> Self {
-        let mut host_url = host_url;
-
-        // we need a trailing slash, if not present we append it
-        if !host_url.ends_with('/') {
-            host_url.push('/');
-        }
-
-        let http_client = NativeHttpClient::new();
-
-        Self {
-            http_client,
-            host_url,
-        }
-    }
-
-    pub fn host_url(&self) -> &str {
-        &self.host_url
-    }
-
-    pub fn http_client(&self) -> &NativeHttpClient {
-        &self.http_client
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl BlindbitClient for NativeBlindbitClient {
-    type Client = NativeHttpClient;
-
-    fn host_url(&self) -> &str {
-        &self.host_url
-    }
-    fn http_client(&self) -> &Self::Client {
-        &self.http_client
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-#[wasm_bindgen]
-#[derive(Clone)]
-pub struct WasmBlindbitClient {
-    http_client: Rc<WasmHttpClient>,
-    host_url: String,
-}
-
-#[cfg(target_arch = "wasm32")]
-impl WasmBlindbitClient {
-    pub fn http_client(&self) -> &WasmHttpClient {
-        self.http_client.as_ref()
-    }
-}
-#[cfg(target_arch = "wasm32")]
-#[wasm_bindgen]
-impl WasmBlindbitClient {
-    #[wasm_bindgen(constructor)]
-    pub fn new(host_url: String, http_client: JsValue) -> Self {
-        let js_client = http_client.dyn_into().unwrap_or_else(|_| {
-            wasm_bindgen::throw_str("Failed to convert to JsHttpClient");
-        });
-        let wasm_client = WasmHttpClient::new(js_client);
-        Self {
-            http_client: Rc::new(wasm_client),
-            host_url,
-        }
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-impl BlindbitClient for WasmBlindbitClient {
-    type Client = WasmHttpClient;
-
-    fn host_url(&self) -> &str {
-        &self.host_url
-    }
-    fn http_client(&self) -> &Self::Client {
-        self.http_client.as_ref()
-    }
-}
diff --git a/src/backend/blindbit/client/mod.rs b/src/backend/blindbit/client/mod.rs
index 4a86e62..834e10d 100644
--- a/src/backend/blindbit/client/mod.rs
+++ b/src/backend/blindbit/client/mod.rs
@@ -1,10 +1,7 @@
-pub mod client;
-pub mod structs;
+#[cfg(all(feature = "blindbit-native", not(target_arch = "wasm32")))]
+pub mod native;
 
-#[cfg(target_arch = "wasm32")]
-pub use client::WasmBlindbitClient;
+#[cfg(all(feature = "blindbit-wasm", target_arch = "wasm32"))]
+pub mod wasm;
 
-#[cfg(not(target_arch = "wasm32"))]
-pub use client::NativeBlindbitClient;
-
-pub use client::BlindbitClient;
+mod structs;
diff --git a/src/backend/blindbit/client/native.rs b/src/backend/blindbit/client/native.rs
new file mode 100644
index 0000000..42e9a80
--- /dev/null
+++ b/src/backend/blindbit/client/native.rs
@@ -0,0 +1,102 @@
+use anyhow::Result;
+use bitcoin::{absolute::Height, secp256k1::PublicKey, Amount, Txid};
+
+use crate::backend::http_client::native::{NativeHttpClient, NativeHttpClientTrait};
+
+use crate::backend::blindbit::client::structs::InfoResponse;
+
+use super::structs::{
+    BlockHeightResponse, FilterResponse, ForwardTxRequest, SpentIndexResponse, UtxoResponse,
+};
+
+#[derive(Clone, Debug)]
+pub struct NativeBlindbitClient {
+    http_client: NativeHttpClient,
+    host_url: String,
+}
+
+impl NativeBlindbitClient {
+    pub fn host_url(&self) -> &str {
+        &self.host_url
+    }
+    pub fn http_client(&self) -> &NativeHttpClient {
+        &self.http_client
+    }
+
+    pub fn new(host_url: String) -> Self {
+        let mut host_url = host_url;
+
+        // we need a trailing slash, if not present we append it
+        if !host_url.ends_with('/') {
+            host_url.push('/');
+        }
+
+        let http_client = NativeHttpClient::new();
+
+        Self {
+            http_client,
+            host_url,
+        }
+    }
+
+    pub async fn block_height(&self) -> Result<Height> {
+        let url = format!("{}block-height", self.host_url());
+        let blkheight: BlockHeightResponse = self.http_client().get(&url).await?;
+        Ok(blkheight.block_height)
+    }
+
+    pub async fn tweaks(&self, block_height: Height, dust_limit: Amount) -> Result<Vec<PublicKey>> {
+        let url = format!(
+            "{}tweaks/{}?dustLimit={}",
+            self.host_url(),
+            block_height,
+            dust_limit.to_sat()
+        );
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn tweak_index(
+        &self,
+        block_height: Height,
+        dust_limit: Amount,
+    ) -> Result<Vec<PublicKey>> {
+        let url = format!(
+            "{}tweak-index/{}?dustLimit={}",
+            self.host_url(),
+            block_height,
+            dust_limit.to_sat()
+        );
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn utxos(&self, block_height: Height) -> Result<Vec<UtxoResponse>> {
+        let url = format!("{}utxos/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn spent_index(&self, block_height: Height) -> Result<SpentIndexResponse> {
+        let url = format!("{}spent-index/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn filter_new_utxos(&self, block_height: Height) -> Result<FilterResponse> {
+        let url = format!("{}filter/new-utxos/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn filter_spent(&self, block_height: Height) -> Result<FilterResponse> {
+        let url = format!("{}filter/spent/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn forward_tx(&self, tx_hex: String) -> Result<Txid> {
+        let url = format!("{}forward-tx", self.host_url());
+        let body = ForwardTxRequest::new(tx_hex);
+        Ok(self.http_client().post(&url, &body).await?)
+    }
+
+    pub async fn info(&self) -> Result<InfoResponse> {
+        let url = format!("{}info", self.host_url());
+        Ok(self.http_client().get(&url).await?)
+    }
+}
diff --git a/src/backend/blindbit/client/wasm.rs b/src/backend/blindbit/client/wasm.rs
new file mode 100644
index 0000000..91baa51
--- /dev/null
+++ b/src/backend/blindbit/client/wasm.rs
@@ -0,0 +1,100 @@
+use std::rc::Rc;
+
+use anyhow::Result;
+use bitcoin::{absolute::Height, secp256k1::PublicKey, Amount, Txid};
+use wasm_bindgen::prelude::*;
+
+use crate::backend::{blindbit::client::structs::{BlockHeightResponse, FilterResponse, ForwardTxRequest, InfoResponse, SpentIndexResponse, UtxoResponse}, http_client::wasm::{WasmHttpClient, WasmHttpClientTrait}};
+
+#[wasm_bindgen]
+#[derive(Clone)]
+pub struct WasmBlindbitClient {
+    http_client: Rc<WasmHttpClient>,
+    host_url: String,
+}
+
+#[wasm_bindgen]
+impl WasmBlindbitClient {
+    #[wasm_bindgen(constructor)]
+    pub fn new(host_url: String, http_client: JsValue) -> Self {
+        let js_client = http_client.dyn_into().unwrap_or_else(|_| {
+            wasm_bindgen::throw_str("Failed to convert to JsHttpClient");
+        });
+        let wasm_client = WasmHttpClient::new(js_client);
+        Self {
+            http_client: Rc::new(wasm_client),
+            host_url,
+        }
+    }
+}
+
+impl WasmBlindbitClient {
+    pub fn host_url(&self) -> &str {
+        &self.host_url
+    }
+
+    pub fn http_client(&self) -> &WasmHttpClient {
+        self.http_client.as_ref()
+    }
+
+    pub async fn block_height(&self) -> Result<Height> {
+        let url = format!("{}block-height", self.host_url());
+        let blkheight: BlockHeightResponse = self.http_client().get(&url).await?;
+        Ok(blkheight.block_height)
+    }
+
+    pub async fn tweaks(&self, block_height: Height, dust_limit: Amount) -> Result<Vec<PublicKey>> {
+        let url = format!(
+            "{}tweaks/{}?dustLimit={}",
+            self.host_url(),
+            block_height,
+            dust_limit.to_sat()
+        );
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn tweak_index(
+        &self,
+        block_height: Height,
+        dust_limit: Amount,
+    ) -> Result<Vec<PublicKey>> {
+        let url = format!(
+            "{}tweak-index/{}?dustLimit={}",
+            self.host_url(),
+            block_height,
+            dust_limit.to_sat()
+        );
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn utxos(&self, block_height: Height) -> Result<Vec<UtxoResponse>> {
+        let url = format!("{}utxos/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn spent_index(&self, block_height: Height) -> Result<SpentIndexResponse> {
+        let url = format!("{}spent-index/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn filter_new_utxos(&self, block_height: Height) -> Result<FilterResponse> {
+        let url = format!("{}filter/new-utxos/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn filter_spent(&self, block_height: Height) -> Result<FilterResponse> {
+        let url = format!("{}filter/spent/{}", self.host_url(), block_height);
+        Ok(self.http_client().get(&url).await?)
+    }
+
+    pub async fn forward_tx(&self, tx_hex: String) -> Result<Txid> {
+        let url = format!("{}forward-tx", self.host_url());
+        let body = ForwardTxRequest::new(tx_hex);
+        Ok(self.http_client().post(&url, &body).await?)
+    }
+
+    pub async fn info(&self) -> Result<InfoResponse> {
+        let url = format!("{}info", self.host_url());
+        Ok(self.http_client().get(&url).await?)
+    }
+}
diff --git a/src/backend/blindbit/mod.rs b/src/backend/blindbit/mod.rs
index cd8074d..da39ec2 100644
--- a/src/backend/blindbit/mod.rs
+++ b/src/backend/blindbit/mod.rs
@@ -1,14 +1,2 @@
 pub mod backend;
 pub mod client;
-
-#[cfg(target_arch = "wasm32")]
-pub use backend::WasmBlindbitBackend;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub use backend::NativeBlindbitBackend;
-
-#[cfg(target_arch = "wasm32")]
-pub use client::WasmBlindbitClient;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub use client::NativeBlindbitClient;
diff --git a/src/backend/backend.rs b/src/backend/chain_backend.rs
similarity index 91%
rename from src/backend/backend.rs
rename to src/backend/chain_backend.rs
index 26a86d2..684a5aa 100644
--- a/src/backend/backend.rs
+++ b/src/backend/chain_backend.rs
@@ -7,7 +7,6 @@ use futures::Stream;
 
 use super::structs::{BlockData, SpentIndexData, UtxoData};
 
-#[cfg(not(target_arch = "wasm32"))]
 #[async_trait]
 pub trait ChainBackend {
     fn get_block_data_for_range(
@@ -24,8 +23,7 @@ pub trait ChainBackend {
     async fn block_height(&self) -> Result<Height>;
 }
 
-// WASM-specific version without Send bounds
-#[cfg(target_arch = "wasm32")]
+// WASM-specific version without Send bounds (no concurrency)
 #[async_trait(?Send)]
 pub trait ChainBackendWasm {
     fn get_block_data_for_range(
diff --git a/src/backend/http_client/mod.rs b/src/backend/http_client/mod.rs
new file mode 100644
index 0000000..53421b4
--- /dev/null
+++ b/src/backend/http_client/mod.rs
@@ -0,0 +1,8 @@
+// HTTP Client module for both native and WASM targets
+// This module provides a unified interface for HTTP operations
+
+#[cfg(all(feature = "blindbit-native", not(target_arch = "wasm32")))]
+pub mod native;
+
+#[cfg(all(feature = "blindbit-wasm", target_arch = "wasm32"))]
+pub mod wasm; 
diff --git a/src/backend/http_client/native.rs b/src/backend/http_client/native.rs
new file mode 100644
index 0000000..3fb9595
--- /dev/null
+++ b/src/backend/http_client/native.rs
@@ -0,0 +1,46 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use serde::{de::DeserializeOwned, Serialize};
+
+#[async_trait]
+pub trait NativeHttpClientTrait {
+    async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T>;
+    async fn post<T: DeserializeOwned>(
+        &self,
+        url: &str,
+        body: &(impl Serialize + Sync),
+    ) -> Result<T>;
+}
+
+// Native implementation using reqwest
+#[derive(Clone, Debug)]
+pub struct NativeHttpClient {
+    client: reqwest::Client,
+}
+
+impl NativeHttpClient {
+    pub fn new() -> Self {
+        Self {
+            client: reqwest::Client::new(),
+        }
+    }
+}
+
+#[async_trait]
+impl NativeHttpClientTrait for NativeHttpClient {
+    async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T> {
+        let response = self.client.get(url).send().await?;
+        let text: String = response.text().await?;
+        Ok(serde_json::from_str(&text)?)
+    }
+
+    async fn post<T: DeserializeOwned>(
+        &self,
+        url: &str,
+        body: &(impl Serialize + Sync),
+    ) -> Result<T> {
+        let response = self.client.post(url).json(body).send().await?;
+        let text: String = response.text().await?;
+        Ok(serde_json::from_str(&text)?)
+    }
+}
diff --git a/src/backend/http_client.rs b/src/backend/http_client/wasm.rs
similarity index 53%
rename from src/backend/http_client.rs
rename to src/backend/http_client/wasm.rs
index 9c4c992..e31b427 100644
--- a/src/backend/http_client.rs
+++ b/src/backend/http_client/wasm.rs
@@ -1,74 +1,20 @@
 use anyhow::Result;
 use async_trait::async_trait;
 use serde::{de::DeserializeOwned, Serialize};
+use js_sys::Promise;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::JsFuture;
 
-// Define the trait differently for WASM vs native
-#[cfg(not(target_arch = "wasm32"))]
-#[async_trait]
-pub trait HttpClient {
-    async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T>;
-    async fn post<T: DeserializeOwned>(
-        &self,
-        url: &str,
-        body: &(impl Serialize + Sync),
-    ) -> Result<T>;
-}
-
-#[cfg(target_arch = "wasm32")]
 #[async_trait(?Send)]
-pub trait HttpClient {
+pub trait WasmHttpClientTrait {
     async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T>;
     async fn post<T: DeserializeOwned>(
         &self,
         url: &str,
-        body: &(impl Serialize + Sync),
+        body: &impl Serialize,
     ) -> Result<T>;
 }
 
-// Native implementation using reqwest
-#[cfg(not(target_arch = "wasm32"))]
-#[derive(Clone, Debug)]
-pub struct NativeHttpClient {
-    client: reqwest::Client,
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl NativeHttpClient {
-    pub fn new() -> Self {
-        Self {
-            client: reqwest::Client::new(),
-        }
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-#[async_trait]
-impl HttpClient for NativeHttpClient {
-    async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T> {
-        let response = self.client.get(url).send().await?;
-        let text: String = response.text().await?;
-        Ok(serde_json::from_str(&text)?)
-    }
-
-    async fn post<T: DeserializeOwned>(
-        &self,
-        url: &str,
-        body: &(impl Serialize + Sync),
-    ) -> Result<T> {
-        let response = self.client.post(url).json(body).send().await?;
-        let text: String = response.text().await?;
-        Ok(serde_json::from_str(&text)?)
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-use js_sys::Promise;
-#[cfg(target_arch = "wasm32")]
-use wasm_bindgen::prelude::*;
-#[cfg(target_arch = "wasm32")]
-use wasm_bindgen_futures::JsFuture;
-
-#[cfg(target_arch = "wasm32")]
 #[wasm_bindgen]
 extern "C" {
     pub type JsHttpClient;
@@ -80,21 +26,18 @@ extern "C" {
     fn post(this: &JsHttpClient, url: &str, body: &JsValue) -> Result<Promise, JsValue>;
 }
 
-#[cfg(target_arch = "wasm32")]
 pub struct WasmHttpClient {
     pub inner: JsHttpClient,
 }
 
-#[cfg(target_arch = "wasm32")]
 impl WasmHttpClient {
     pub fn new(inner: JsHttpClient) -> Self {
         Self { inner }
     }
 }
 
-#[cfg(target_arch = "wasm32")]
-#[async_trait::async_trait(?Send)]
-impl HttpClient for WasmHttpClient {
+#[async_trait(?Send)]
+impl WasmHttpClientTrait for WasmHttpClient {
     async fn get<T: DeserializeOwned>(&self, url: &str) -> Result<T> {
         let p = self
             .inner
@@ -111,7 +54,7 @@ impl HttpClient for WasmHttpClient {
     async fn post<T: DeserializeOwned>(
         &self,
         url: &str,
-        body: &(impl Serialize + Sync),
+        body: &impl Serialize,
     ) -> Result<T> {
         let body_js = serde_wasm_bindgen::to_value(body)
             .map_err(|e| anyhow::anyhow!("serialize body error: {}", e))?;
diff --git a/src/backend/mod.rs b/src/backend/mod.rs
index af37d07..dce3d10 100644
--- a/src/backend/mod.rs
+++ b/src/backend/mod.rs
@@ -1,29 +1,24 @@
-mod backend;
-#[cfg(feature = "blindbit-backend")]
+mod chain_backend;
 mod blindbit;
 mod http_client;
-mod structs;
+pub mod structs;
 
-#[cfg(target_arch = "wasm32")]
-pub use backend::ChainBackendWasm;
+#[cfg(all(feature = "blindbit-wasm", target_arch = "wasm32"))]
+pub use chain_backend::ChainBackendWasm;
 
-#[cfg(not(target_arch = "wasm32"))]
-pub use backend::ChainBackend;
+#[cfg(all(feature = "blindbit-native", not(target_arch = "wasm32")))]
+pub use chain_backend::ChainBackend;
 
 pub use structs::*;
 
-#[cfg(feature = "blindbit-backend")]
-#[cfg(not(target_arch = "wasm32"))]
-pub use blindbit::backend::NativeBlindbitBackend;
+#[cfg(all(feature = "blindbit-native", not(target_arch = "wasm32")))]
+pub use crate::backend::blindbit::backend::native::NativeBlindbitBackend;
 
-#[cfg(feature = "blindbit-backend")]
-#[cfg(target_arch = "wasm32")]
-pub use blindbit::backend::WasmBlindbitBackend;
+#[cfg(all(feature = "blindbit-wasm", target_arch = "wasm32"))]
+pub use crate::backend::blindbit::backend::wasm::WasmBlindbitBackend;
 
-#[cfg(target_arch = "wasm32")]
-#[cfg(feature = "blindbit-backend")]
-pub use blindbit::client::client::WasmBlindbitClient;
+#[cfg(all(feature = "blindbit-wasm", target_arch = "wasm32"))]
+pub use blindbit::client::wasm::WasmBlindbitClient;
 
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(feature = "blindbit-backend")]
-pub use blindbit::client::client::NativeBlindbitClient;
+#[cfg(all(feature = "blindbit-native", not(target_arch = "wasm32")))]
+pub use blindbit::client::native::NativeBlindbitClient;
diff --git a/src/client/client.rs b/src/client/client.rs
index b980af6..61fdb32 100644
--- a/src/client/client.rs
+++ b/src/client/client.rs
@@ -104,40 +104,44 @@ impl SpClient {
         }
     }
 
-    pub fn get_script_to_secret_map(
+    #[cfg(feature = "blindbit-native")]
+    pub fn get_script_to_secret_map_par(
         &self,
         tweak_data_vec: Vec<PublicKey>,
     ) -> Result<HashMap<[u8; 34], PublicKey>> {
         let b_scan = &self.get_scan_key();
 
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            use rayon::prelude::*;
+        use rayon::prelude::*;
 
-            let shared_secrets: Vec<PublicKey> = tweak_data_vec
-                .into_par_iter()
-                .map(|tweak| sp_utils::receiving::calculate_ecdh_shared_secret(&tweak, b_scan))
-                .collect();
+        let shared_secrets: Vec<PublicKey> = tweak_data_vec
+            .into_par_iter()
+            .map(|tweak| sp_utils::receiving::calculate_ecdh_shared_secret(&tweak, b_scan))
+            .collect();
 
-            let items: Result<Vec<_>> = shared_secrets
-                .into_par_iter()
-                .map(|secret| {
-                    let spks = self.sp_receiver.get_spks_from_shared_secret(&secret)?;
+        let items: Result<Vec<_>> = shared_secrets
+            .into_par_iter()
+            .map(|secret| {
+                let spks = self.sp_receiver.get_spks_from_shared_secret(&secret)?;
 
-                    Ok((secret, spks.into_values()))
-                })
-                .collect();
+                Ok((secret, spks.into_values()))
+            })
+            .collect();
 
-            let mut res = HashMap::new();
-            for (secret, spks) in items? {
-                for spk in spks {
-                    res.insert(spk, secret);
-                }
+        let mut res = HashMap::new();
+        for (secret, spks) in items? {
+            for spk in spks {
+                res.insert(spk, secret);
             }
-            Ok(res)
         }
+        Ok(res)
+    }
+
+    pub fn get_script_to_secret_map(
+        &self,
+        tweak_data_vec: Vec<PublicKey>,
+    ) -> Result<HashMap<[u8; 34], PublicKey>> {
+        let b_scan = &self.get_scan_key();
 
-        #[cfg(target_arch = "wasm32")]
         {
             // Sequential fallback for WASM
             let shared_secrets: Vec<PublicKey> = tweak_data_vec
diff --git a/src/scanner/mod.rs b/src/scanner/mod.rs
index f53a47e..3a8f9e8 100644
--- a/src/scanner/mod.rs
+++ b/src/scanner/mod.rs
@@ -13,12 +13,6 @@ use crate::{
     updater::Updater,
 };
 
-#[cfg(not(target_arch = "wasm32"))]
-use crate::backend::ChainBackend;
-
-#[cfg(target_arch = "wasm32")]
-use crate::backend::ChainBackendWasm;
-
 /// Trait for scanning silent payment blocks
 ///
 /// This trait abstracts the core scanning functionality, allowing consumers
@@ -83,22 +77,6 @@ pub trait SpScanner {
         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
@@ -145,14 +123,6 @@ pub trait SpScanner {
     /// Get the silent payment client
     fn client(&self) -> &SpClient;
 
-    /// Get the chain backend
-    #[cfg(not(target_arch = "wasm32"))]
-    fn backend(&self) -> &dyn ChainBackend;
-
-    /// Get the chain backend (WASM version)
-    #[cfg(target_arch = "wasm32")]
-    fn backend(&self) -> &dyn ChainBackendWasm;
-
     /// Get the updater
     fn updater(&mut self) -> &mut dyn Updater;
 
@@ -166,54 +136,54 @@ pub trait SpScanner {
         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();
-            }
-        }
+    ) -> Result<()>;
+    //     use futures::StreamExt;
+    //     use std::time::{Duration, Instant};
 
-        Ok(())
-    }
+    //     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
     ///
@@ -222,74 +192,74 @@ pub trait SpScanner {
         &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)
-    }
+    ) -> 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
     ///
@@ -316,13 +286,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
     ///