silent_payments_scan/

index_server.rs

//! BIP0352 index server scanning backend.
//!
//! [`IndexServerBackend`] implements [`ScanBackend`] for scanning via a BIP0352
//! index server (e.g., BlindBit oracle). The server provides pre-computed tweak
//! data (`A_sum * input_hash`) per block, enabling lightweight client-side
//! scanning without full transaction data.
//!
//! # Protocol
//!
//! For each block in the scan range:
//! 1. Fetch tweaks via `GET /tweaks/:height` (pre-computed `A_sum * input_hash`)
//! 2. Fetch UTXOs via `GET /utxos/:height` (taproot outputs in the block)
//! 3. For each tweak: compute ECDH shared secret, derive candidate script pubkeys
//! 4. Match candidates against the UTXO set
//! 5. Report matches via `on_match` callback, progress via `on_progress`
//!
//! # Feature Gate
//!
//! This module requires the `index-server` feature flag.

use bitcoin::secp256k1::PublicKey;
use bitcoin::{Amount, OutPoint, ScriptBuf, Txid};
use serde::Deserialize;

use silent_payments_core::keys::{ScanSecretKey, SpendPublicKey};
use silent_payments_receive::label::LabelManager;
use silent_payments_receive::DetectedOutput;

use crate::backend::{OnMatch, OnProgress, ScanBackend};
use crate::error::ScanError;

type UtxoEntry = (Txid, u32, Amount, ScriptBuf);
type UtxoLookup = std::collections::HashMap<Vec<u8>, Vec<UtxoEntry>>;

/// A tweak entry from the index server's `/tweaks/:height` endpoint.
///
/// Each tweak represents a transaction's pre-computed `A_sum * input_hash`
/// as a hex-encoded compressed public key.
#[derive(Debug, Deserialize)]
struct TweakResponse {
    /// Transaction ID that produced this tweak.
    txid: String,
    /// Hex-encoded compressed public key (`A_sum * input_hash`).
    tweak_data: String,
}

/// A UTXO entry from the index server's `/utxos/:height` endpoint.
#[derive(Debug, Deserialize)]
struct UtxoResponse {
    /// Transaction ID containing this output.
    txid: String,
    /// Output index within the transaction.
    vout: u32,
    /// Output value in satoshis.
    value: u64,
    /// Hex-encoded scriptPubKey.
    #[serde(alias = "scriptPubKey")]
    script_pub_key: String,
}

/// Scanning backend for BIP0352 index servers.
///
/// Connects to a BIP0352-compatible index server (e.g., BlindBit oracle)
/// that provides pre-computed tweak data per block. This enables lightweight
/// scanning with minimal bandwidth -- the client only performs ECDH and
/// script pubkey derivation, not full transaction parsing.
///
/// # Construction
///
/// ```ignore
/// // Unauthenticated
/// let backend = IndexServerBackend::new("http://localhost:8080");
///
/// // With optional auth token
/// let backend = IndexServerBackend::with_auth("http://localhost:8080", "my-token");
/// ```
///
/// # No Retry Logic
///
/// Connection errors bubble up immediately. The caller owns retry policy.
pub struct IndexServerBackend {
    /// Base URL of the index server (trailing slash trimmed).
    base_url: String,
    /// Optional authorization token sent as Bearer header.
    auth_token: Option<String>,
}

impl IndexServerBackend {
    /// Create a new index server backend.
    ///
    /// The `base_url` trailing slash is trimmed for consistent path joining.
    pub fn new(base_url: &str) -> Self {
        Self {
            base_url: base_url.trim_end_matches('/').to_string(),
            auth_token: None,
        }
    }

    /// Create a new index server backend with an authorization token.
    ///
    /// The token is sent as a `Bearer` token in the `Authorization` header.
    pub fn with_auth(base_url: &str, token: &str) -> Self {
        Self {
            base_url: base_url.trim_end_matches('/').to_string(),
            auth_token: Some(token.to_string()),
        }
    }

    /// Fetch JSON from the index server.
    ///
    /// Builds the full URL from `base_url + path`, adds auth header if present,
    /// and deserializes the response body.
    fn fetch_json<T: serde::de::DeserializeOwned>(&self, path: &str) -> Result<T, ScanError> {
        let url = format!("{}{}", self.base_url, path);

        let mut request = minreq::get(&url);
        if let Some(ref token) = self.auth_token {
            request = request.with_header("Authorization", format!("Bearer {token}"));
        }

        let response = request
            .send()
            .map_err(|e| ScanError::Connection(e.to_string()))?;

        if response.status_code != 200 {
            return Err(ScanError::Backend(format!(
                "HTTP {}: {}",
                response.status_code,
                response.as_str().unwrap_or("unknown error")
            )));
        }

        serde_json::from_str(
            response
                .as_str()
                .map_err(|e| ScanError::Backend(format!("invalid UTF-8 response: {e}")))?,
        )
        .map_err(|e| ScanError::Backend(format!("JSON parse error: {e}")))
    }

    /// Derive candidate script pubkeys from a tweak for matching against UTXOs.
    ///
    /// For each tweak (pre-computed `A_sum * input_hash` from the server):
    /// 1. Compute ECDH shared secret: `b_scan * tweak`
    /// 2. Derive base SPK at k=0 (unlabeled)
    /// 3. Derive labeled SPKs for each registered label
    ///
    /// Returns `(script_pubkey, label_index)` pairs. `label_index` is `None`
    /// for the base (unlabeled) SPK.
    fn derive_candidate_spks(
        scan_sk: &ScanSecretKey,
        spend_pk: &SpendPublicKey,
        tweak_pubkey: &PublicKey,
        labels: &LabelManager,
    ) -> Vec<(ScriptBuf, Option<u32>)> {
        // ECDH shared secret: b_scan * tweak
        let ecdh_shared_secret = bdk_sp::compute_shared_secret(scan_sk.as_inner(), tweak_pubkey);

        let labels_btree = labels.to_btree();

        // Base SPK (k=0, no label)
        let base_spk = bdk_sp::receive::get_silentpayment_script_pubkey(
            spend_pk.as_inner(),
            &ecdh_shared_secret,
            0,
            None,
        );

        let mut candidates = vec![(base_spk, None)];

        // Labeled SPKs (k=0, with each registered label)
        for (label_pk, (_scalar, label_index)) in &labels_btree {
            let labeled_spk = bdk_sp::receive::get_silentpayment_script_pubkey(
                spend_pk.as_inner(),
                &ecdh_shared_secret,
                0,
                Some(label_pk),
            );
            candidates.push((labeled_spk, Some(*label_index)));
        }

        candidates
    }

    /// Parse a hex-encoded compressed public key from the index server.
    fn parse_tweak_pubkey(hex_str: &str) -> Result<PublicKey, ScanError> {
        let bytes = hex_to_bytes(hex_str)
            .map_err(|e| ScanError::Backend(format!("invalid tweak hex: {e}")))?;
        PublicKey::from_slice(&bytes)
            .map_err(|e| ScanError::Backend(format!("invalid tweak pubkey: {e}")))
    }

    /// Parse a txid from hex string.
    fn parse_txid(hex_str: &str) -> Result<Txid, ScanError> {
        hex_str
            .parse::<Txid>()
            .map_err(|e| ScanError::Backend(format!("invalid txid: {e}")))
    }

    /// Parse a hex-encoded script pubkey.
    fn parse_script_pubkey(hex_str: &str) -> Result<ScriptBuf, ScanError> {
        let bytes = hex_to_bytes(hex_str)
            .map_err(|e| ScanError::Backend(format!("invalid script hex: {e}")))?;
        Ok(ScriptBuf::from_bytes(bytes))
    }

    /// Access the base URL (for testing).
    #[cfg(test)]
    fn base_url(&self) -> &str {
        &self.base_url
    }

    /// Access the auth token (for testing).
    #[cfg(test)]
    fn auth_token(&self) -> Option<&str> {
        self.auth_token.as_deref()
    }
}

/// Decode a hex string into bytes.
fn hex_to_bytes(hex: &str) -> Result<Vec<u8>, String> {
    if hex.len() % 2 != 0 {
        return Err("odd-length hex string".to_string());
    }
    (0..hex.len())
        .step_by(2)
        .map(|i| {
            u8::from_str_radix(&hex[i..i + 2], 16)
                .map_err(|e| format!("invalid hex at position {i}: {e}"))
        })
        .collect()
}

impl ScanBackend for IndexServerBackend {
    fn scan_range(
        &self,
        from_height: u32,
        to_height: u32,
        scan_secret: &ScanSecretKey,
        spend_pubkey: &SpendPublicKey,
        labels: &LabelManager,
        on_match: OnMatch<'_>,
        on_progress: OnProgress<'_>,
    ) -> Result<(), ScanError> {
        for height in from_height..=to_height {
            // Fetch tweaks for this block
            let tweaks: Vec<TweakResponse> = self.fetch_json(&format!("/tweaks/{height}"))?;

            // Fetch UTXOs for this block
            let utxos: Vec<UtxoResponse> = self.fetch_json(&format!("/utxos/{height}"))?;

            // Build a lookup of UTXO script pubkeys for matching
            // Key: script_pubkey hex, Value: vec of (txid, vout, value, script)
            let mut utxo_lookup: UtxoLookup = UtxoLookup::new();

            for utxo in &utxos {
                let txid = Self::parse_txid(&utxo.txid)?;
                let script = Self::parse_script_pubkey(&utxo.script_pub_key)?;
                let amount = Amount::from_sat(utxo.value);
                utxo_lookup
                    .entry(script.as_bytes().to_vec())
                    .or_default()
                    .push((txid, utxo.vout, amount, script));
            }

            // For each tweak, derive candidate SPKs and match against UTXOs
            for tweak_resp in &tweaks {
                let tweak_pubkey = Self::parse_tweak_pubkey(&tweak_resp.tweak_data)?;
                let tweak_txid = Self::parse_txid(&tweak_resp.txid)?;

                let candidates =
                    Self::derive_candidate_spks(scan_secret, spend_pubkey, &tweak_pubkey, labels);

                // Also derive k=1,2,... candidates if we find matches at k=0
                // For simplicity, start with k=0 only (most common case).
                // BIP 352 specifies incrementing k per additional output to the
                // same recipient within a single transaction.
                let mut k = 0u32;
                let mut found_at_k = true;

                while found_at_k {
                    found_at_k = false;

                    let current_candidates = if k == 0 {
                        // Already computed above
                        candidates.clone()
                    } else {
                        // Derive candidates for higher k values
                        let ecdh_shared_secret =
                            bdk_sp::compute_shared_secret(scan_secret.as_inner(), &tweak_pubkey);
                        let labels_btree = labels.to_btree();

                        let base_spk = bdk_sp::receive::get_silentpayment_script_pubkey(
                            spend_pubkey.as_inner(),
                            &ecdh_shared_secret,
                            k,
                            None,
                        );
                        let mut higher_candidates = vec![(base_spk, None)];
                        for (label_pk, (_scalar, label_index)) in &labels_btree {
                            let labeled_spk = bdk_sp::receive::get_silentpayment_script_pubkey(
                                spend_pubkey.as_inner(),
                                &ecdh_shared_secret,
                                k,
                                Some(label_pk),
                            );
                            higher_candidates.push((labeled_spk, Some(*label_index)));
                        }
                        higher_candidates
                    };

                    for (candidate_spk, label_index) in &current_candidates {
                        let spk_bytes = candidate_spk.as_bytes().to_vec();
                        if let Some(matching_utxos) = utxo_lookup.get(&spk_bytes) {
                            for (utxo_txid, vout, amount, script) in matching_utxos {
                                // Verify the UTXO belongs to the tweak's transaction
                                // (index servers return all UTXOs for a block, but
                                // each tweak corresponds to a specific transaction)
                                if *utxo_txid != tweak_txid {
                                    continue;
                                }

                                // Compute the tweak secret key for DetectedOutput
                                let ecdh = bdk_sp::compute_shared_secret(
                                    scan_secret.as_inner(),
                                    &tweak_pubkey,
                                );
                                let t_k = bdk_sp::hashes::get_shared_secret(ecdh, k);

                                // If labeled, add the label tweak
                                let final_tweak = if let Some(label_m) = label_index {
                                    let label_scalar = bdk_sp::hashes::get_label_tweak(
                                        *scan_secret.as_inner(),
                                        *label_m,
                                    );
                                    t_k.add_tweak(&label_scalar).map_err(|e| {
                                        ScanError::Backend(format!(
                                            "label tweak addition failed: {e}"
                                        ))
                                    })?
                                } else {
                                    t_k
                                };

                                let outpoint = OutPoint::new(*utxo_txid, *vout);
                                let detected = DetectedOutput::new(
                                    outpoint,
                                    *amount,
                                    script.clone(),
                                    final_tweak,
                                    *label_index,
                                );

                                on_match(detected);
                                found_at_k = true;
                            }
                        }
                    }

                    k += 1;

                    // Safety bound: BIP 352 practically limits outputs per recipient
                    // per transaction. Prevent infinite loops.
                    if k > 255 {
                        break;
                    }
                }
            }

            on_progress(height);
        }

        Ok(())
    }

    fn scan_transaction(
        &self,
        _txid: &bitcoin::Txid,
        _scan_secret: &ScanSecretKey,
        _spend_pubkey: &SpendPublicKey,
        _labels: &LabelManager,
    ) -> Result<Vec<DetectedOutput>, ScanError> {
        // The index server protocol does not support txid-to-block-height lookup.
        // Callers should use scan_range instead.
        Err(ScanError::Backend(
            "IndexServer backend does not support scan_transaction: \
             the protocol has no txid-to-block-height lookup. \
             Use scan_range with the block height range instead."
                .to_string(),
        ))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn new_trims_trailing_slash() {
        let backend = IndexServerBackend::new("http://localhost:8080/");
        assert_eq!(backend.base_url(), "http://localhost:8080");

        let backend = IndexServerBackend::new("http://localhost:8080///");
        assert_eq!(backend.base_url(), "http://localhost:8080");

        let backend = IndexServerBackend::new("http://localhost:8080");
        assert_eq!(backend.base_url(), "http://localhost:8080");
    }

    #[test]
    fn with_auth_stores_token_and_trims_slash() {
        let backend = IndexServerBackend::with_auth("http://localhost:8080/", "my-secret-token");
        assert_eq!(backend.base_url(), "http://localhost:8080");
        assert_eq!(backend.auth_token(), Some("my-secret-token"));
    }

    #[test]
    fn new_has_no_auth_token() {
        let backend = IndexServerBackend::new("http://localhost:8080");
        assert_eq!(backend.auth_token(), None);
    }

    #[test]
    fn derive_candidate_spks_produces_base_spk() {
        // Use known test keys to verify SPK derivation
        let scan_sk = ScanSecretKey::from_slice(&[
            0xea, 0xdc, 0x78, 0x16, 0x5f, 0xf1, 0xf8, 0xea, 0x94, 0xad, 0x7c, 0xfd, 0xc5, 0x49,
            0x90, 0x73, 0x8a, 0x4c, 0x53, 0xf6, 0xe0, 0x50, 0x7b, 0x42, 0x15, 0x42, 0x01, 0xb8,
            0xe5, 0xdf, 0xf3, 0xb1,
        ])
        .unwrap();

        let spend_sk = silent_payments_core::keys::SpendSecretKey::from_slice(&[
            0x93, 0xf5, 0xed, 0x90, 0x7a, 0xd5, 0xb2, 0xbd, 0xbb, 0xdc, 0xb5, 0xd9, 0x11, 0x6e,
            0xbc, 0x0a, 0x4e, 0x1f, 0x92, 0xf9, 0x10, 0xd5, 0x26, 0x02, 0x37, 0xfa, 0x45, 0xa9,
            0x40, 0x8a, 0xad, 0x16,
        ])
        .unwrap();

        let secp = bitcoin::secp256k1::Secp256k1::new();
        let spend_pk = spend_sk.public_key(&secp);
        let labels = LabelManager::new();

        // Create a known tweak public key (just a deterministic pubkey)
        let tweak_sk = bitcoin::secp256k1::SecretKey::from_slice(&[0x42; 32]).unwrap();
        let tweak_pk = tweak_sk.public_key(&secp);

        let candidates =
            IndexServerBackend::derive_candidate_spks(&scan_sk, &spend_pk, &tweak_pk, &labels);

        // With no labels, should produce exactly 1 candidate (base SPK at k=0)
        assert_eq!(candidates.len(), 1);
        assert!(candidates[0].1.is_none(), "base SPK should have no label");

        // The SPK should be a P2TR script (34 bytes: OP_1 + 32-byte x-only key)
        assert!(candidates[0].0.is_p2tr(), "candidate SPK should be P2TR");

        // Verify determinism: same inputs produce same output
        let candidates2 =
            IndexServerBackend::derive_candidate_spks(&scan_sk, &spend_pk, &tweak_pk, &labels);
        assert_eq!(
            candidates[0].0, candidates2[0].0,
            "derivation must be deterministic"
        );
    }

    #[test]
    fn derive_candidate_spks_with_labels() {
        let secp = bitcoin::secp256k1::Secp256k1::new();

        let scan_sk = ScanSecretKey::from_slice(&[
            0xea, 0xdc, 0x78, 0x16, 0x5f, 0xf1, 0xf8, 0xea, 0x94, 0xad, 0x7c, 0xfd, 0xc5, 0x49,
            0x90, 0x73, 0x8a, 0x4c, 0x53, 0xf6, 0xe0, 0x50, 0x7b, 0x42, 0x15, 0x42, 0x01, 0xb8,
            0xe5, 0xdf, 0xf3, 0xb1,
        ])
        .unwrap();

        let spend_sk = silent_payments_core::keys::SpendSecretKey::from_slice(&[
            0x93, 0xf5, 0xed, 0x90, 0x7a, 0xd5, 0xb2, 0xbd, 0xbb, 0xdc, 0xb5, 0xd9, 0x11, 0x6e,
            0xbc, 0x0a, 0x4e, 0x1f, 0x92, 0xf9, 0x10, 0xd5, 0x26, 0x02, 0x37, 0xfa, 0x45, 0xa9,
            0x40, 0x8a, 0xad, 0x16,
        ])
        .unwrap();

        let spend_pk = spend_sk.public_key(&secp);

        let mut labels = LabelManager::new();
        labels.add_label(&scan_sk, &spend_pk, 1, &secp).unwrap();
        labels.add_label(&scan_sk, &spend_pk, 5, &secp).unwrap();

        let tweak_sk = bitcoin::secp256k1::SecretKey::from_slice(&[0x42; 32]).unwrap();
        let tweak_pk = tweak_sk.public_key(&secp);

        let candidates =
            IndexServerBackend::derive_candidate_spks(&scan_sk, &spend_pk, &tweak_pk, &labels);

        // Should produce 1 base + 2 labeled = 3 candidates
        assert_eq!(candidates.len(), 3);

        // First should be the base (unlabeled)
        assert!(
            candidates[0].1.is_none(),
            "first candidate should be unlabeled base SPK"
        );

        // All should be P2TR
        for (spk, _) in &candidates {
            assert!(spk.is_p2tr(), "all candidates should be P2TR");
        }

        // All SPKs should be different
        let spk_set: std::collections::HashSet<Vec<u8>> = candidates
            .iter()
            .map(|(spk, _)| spk.as_bytes().to_vec())
            .collect();
        assert_eq!(spk_set.len(), 3, "all candidate SPKs must be distinct");
    }

    #[test]
    fn hex_to_bytes_valid() {
        assert_eq!(
            hex_to_bytes("deadbeef").unwrap(),
            vec![0xde, 0xad, 0xbe, 0xef]
        );
        assert_eq!(hex_to_bytes("00ff").unwrap(), vec![0x00, 0xff]);
        assert_eq!(hex_to_bytes("").unwrap(), Vec::<u8>::new());
    }

    #[test]
    fn hex_to_bytes_odd_length_errors() {
        assert!(hex_to_bytes("abc").is_err());
    }

    #[test]
    fn hex_to_bytes_invalid_chars_errors() {
        assert!(hex_to_bytes("zzzz").is_err());
    }

    #[test]
    fn parse_tweak_pubkey_valid() {
        // A known valid compressed public key (33 bytes)
        let secp = bitcoin::secp256k1::Secp256k1::new();
        let sk = bitcoin::secp256k1::SecretKey::from_slice(&[0x42; 32]).unwrap();
        let pk = sk.public_key(&secp);
        let hex = pk.to_string();

        let parsed = IndexServerBackend::parse_tweak_pubkey(&hex).unwrap();
        assert_eq!(parsed, pk);
    }

    #[test]
    fn parse_tweak_pubkey_invalid() {
        let result = IndexServerBackend::parse_tweak_pubkey("not_a_pubkey");
        assert!(result.is_err());
    }

    #[test]
    fn scan_transaction_returns_unsupported_error() {
        let backend = IndexServerBackend::new("http://localhost:8080");

        let scan_sk = ScanSecretKey::from_slice(&[
            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
            0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c,
            0x1d, 0x1e, 0x1f, 0x20,
        ])
        .unwrap();

        let spend_sk = silent_payments_core::keys::SpendSecretKey::from_slice(&[
            0x93, 0xf5, 0xed, 0x90, 0x7a, 0xd5, 0xb2, 0xbd, 0xbb, 0xdc, 0xb5, 0xd9, 0x11, 0x6e,
            0xbc, 0x0a, 0x4e, 0x1f, 0x92, 0xf9, 0x10, 0xd5, 0x26, 0x02, 0x37, 0xfa, 0x45, 0xa9,
            0x40, 0x8a, 0xad, 0x16,
        ])
        .unwrap();

        let secp = bitcoin::secp256k1::Secp256k1::new();
        let spend_pk = spend_sk.public_key(&secp);
        let labels = LabelManager::new();

        let txid: Txid = "0000000000000000000000000000000000000000000000000000000000000000"
            .parse()
            .unwrap();

        let result = backend.scan_transaction(&txid, &scan_sk, &spend_pk, &labels);
        assert!(result.is_err());
        let err = result.unwrap_err();
        assert!(
            matches!(err, ScanError::Backend(_)),
            "should be Backend error, got: {:?}",
            err
        );
        assert!(
            err.to_string().contains("scan_transaction"),
            "error message should mention scan_transaction"
        );
    }

    #[test]
    fn serde_tweak_response_deserializes() {
        let json = r#"{"txid": "abc123", "tweak_data": "02deadbeef"}"#;
        let resp: TweakResponse = serde_json::from_str(json).unwrap();
        assert_eq!(resp.txid, "abc123");
        assert_eq!(resp.tweak_data, "02deadbeef");
    }

    #[test]
    fn serde_utxo_response_deserializes() {
        let json =
            r#"{"txid": "abc123", "vout": 0, "value": 50000, "scriptPubKey": "5120deadbeef"}"#;
        let resp: UtxoResponse = serde_json::from_str(json).unwrap();
        assert_eq!(resp.txid, "abc123");
        assert_eq!(resp.vout, 0);
        assert_eq!(resp.value, 50000);
        assert_eq!(resp.script_pub_key, "5120deadbeef");
    }

    #[test]
    fn serde_utxo_response_snake_case_alias() {
        // Test with snake_case field name (some servers may use this)
        let json = r#"{"txid": "abc123", "vout": 1, "value": 10000, "script_pub_key": "5120aabb"}"#;
        let resp: UtxoResponse = serde_json::from_str(json).unwrap();
        assert_eq!(resp.script_pub_key, "5120aabb");
    }

    #[test]
    #[ignore = "requires running BIP0352 index server at localhost:8080"]
    fn integration_scan_range_against_live_server() {
        let backend = IndexServerBackend::new("http://localhost:8080");
        let scan_sk = ScanSecretKey::from_slice(&[
            0xea, 0xdc, 0x78, 0x16, 0x5f, 0xf1, 0xf8, 0xea, 0x94, 0xad, 0x7c, 0xfd, 0xc5, 0x49,
            0x90, 0x73, 0x8a, 0x4c, 0x53, 0xf6, 0xe0, 0x50, 0x7b, 0x42, 0x15, 0x42, 0x01, 0xb8,
            0xe5, 0xdf, 0xf3, 0xb1,
        ])
        .unwrap();

        let spend_sk = silent_payments_core::keys::SpendSecretKey::from_slice(&[
            0x93, 0xf5, 0xed, 0x90, 0x7a, 0xd5, 0xb2, 0xbd, 0xbb, 0xdc, 0xb5, 0xd9, 0x11, 0x6e,
            0xbc, 0x0a, 0x4e, 0x1f, 0x92, 0xf9, 0x10, 0xd5, 0x26, 0x02, 0x37, 0xfa, 0x45, 0xa9,
            0x40, 0x8a, 0xad, 0x16,
        ])
        .unwrap();

        let secp = bitcoin::secp256k1::Secp256k1::new();
        let spend_pk = spend_sk.public_key(&secp);
        let labels = LabelManager::new();

        let mut matches = Vec::new();
        let mut progress = Vec::new();

        let result = backend.scan_range(
            800_000,
            800_001,
            &scan_sk,
            &spend_pk,
            &labels,
            &mut |output| matches.push(output),
            &mut |height| progress.push(height),
        );

        // At minimum, it should complete without error (server must be running)
        assert!(result.is_ok(), "scan_range failed: {:?}", result);
        assert_eq!(progress, vec![800_000, 800_001]);
    }
}