Backfill pre-birthday Money Merkle leaves and close the native synchronizer on teardown.

Author: nighthawk24

.gitignore

@@ -91,3 +91,7 @@ seed.txt
 seed.txt
 *.seed
 *.mnemonic
+
+# Testnet build & runtime data
+app/darkfitestnet/
+

darkfi-android-sdk/src/main/java/com/nighthawkapps/lib/android/sdk/wallet/DarkfiSynchronizer.kt

@@ -13,7 +13,9 @@ import kotlinx.coroutines.flow.flowOf
  * **Chain / tx submission** is expected to flow through **darkfid** JSON-RPC (`DarkfidJsonRpc`) or
  * JNI from `drk`; this interface stays transport-agnostic until the native layer lands.
  */
-interface DarkfiSynchronizer {
+interface DarkfiSynchronizer : java.io.Closeable {
+    override fun close() {}
+
     val status: Flow<DarkfiSyncStatus>
     val processorInfo: Flow<DarkfiProcessorInfo>
     val progress: Flow<DarkfiPercent>

darkfi-android-sdk/src/main/java/com/nighthawkapps/lib/android/sdk/wallet/DarkfiWalletCoordinator.kt

@@ -34,6 +34,7 @@ class DarkfiWalletCoordinator internal constructor(
     init {
         scope.launch(Dispatchers.IO) {
             walletFlow.collectLatest { wallet ->
+                _synchronizer.value?.close()
                 _synchronizer.value =
                     wallet?.let { w ->
                         DarkfiSynchronizerFactory.create(w, appContext, useNativeSynchronizer)
@@ -52,6 +53,7 @@ class DarkfiWalletCoordinator internal constructor(
     fun reloadSynchronizer() {
         scope.launch(Dispatchers.IO) {
             val wallet = persistableWallet.value ?: return@launch
+            _synchronizer.value?.close()
             _synchronizer.value =
                 DarkfiSynchronizerFactory.create(wallet, appContext, useNativeSynchronizer)
         }
@@ -67,6 +69,7 @@ class DarkfiWalletCoordinator internal constructor(
     }
 
     fun resetSdk() {
+        _synchronizer.value?.close()
         _synchronizer.value = null
     }
 

darkfi-android-sdk/src/main/java/com/nighthawkapps/lib/android/sdk/wallet/NativeDarkfiSynchronizer.kt

@@ -10,7 +10,9 @@ import com.nighthawkapps.lib.uniffi.darkfi_mobile_ffi.ReorgEvent
 import com.nighthawkapps.lib.uniffi.darkfi_mobile_ffi.ReorgEventCallback
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -51,6 +53,7 @@ class NativeDarkfiSynchronizer internal constructor(
     private val _fallbackReason = MutableStateFlow("")
     private val _fallbackUserMessage = MutableStateFlow("")
     private val syncScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private var syncJob: Job? = null
 
     init {
         handle.setReorgCallback(
@@ -92,14 +95,11 @@ class NativeDarkfiSynchronizer internal constructor(
     override fun applyDarkfidReachability(reachable: Boolean) {
         if (reachable) {
             _walletErrors.value = null
-        }
-        _status.value =
-            when {
-                !reachable -> DarkfiSyncStatus.DISCONNECTED
-                _status.value == DarkfiSyncStatus.SYNCING -> DarkfiSyncStatus.SYNCING
-                else -> DarkfiSyncStatus.SYNCED
-            }
-        if (!reachable) {
+            // Don't prematurely set SYNCED — delegate to the snapshot so the
+            // reported status reflects the actual sync state from the FFI layer.
+            applySyncSnapshotBestEffort()
+        } else {
+            _status.value = DarkfiSyncStatus.DISCONNECTED
             _walletErrors.value =
                 DarkfiWalletError.Processor(
                     IllegalStateException(
@@ -349,14 +349,19 @@ class NativeDarkfiSynchronizer internal constructor(
     }
 
     private fun startSyncProgressPolling() {
-        syncScope.launch {
+        syncJob = syncScope.launch {
             while (isActive) {
                 applySyncSnapshotBestEffort()
                 delay(SYNC_PROGRESS_POLL_MS)
             }
         }
     }
 
+    override fun close() {
+        syncJob?.cancel()
+        syncScope.cancel()
+    }
+
     private companion object {
         const val SYNC_PROGRESS_POLL_MS = 15_000L
     }

rust/darkfi-mobile-ffi/src/bootstrap.rs

@@ -78,6 +78,25 @@ pub async fn bootstrap_drk(
         } else {
             seed_birthday_scan_cursor(&drk, birthday).await?;
         }
+
+        // Backfill the Money Merkle tree with pre-birthday note commitments so
+        // spend proofs use a root that includes genesis..birthday-1. Without
+        // this, the local tree only has leaves from birthday..tip and computed
+        // Merkle roots won't match any valid on-chain anchor.
+        let pin = pin_from_config(config);
+        if let Err(e) = backfill_money_tree_to_birthday(
+            &drk,
+            birthday,
+            &config.lightwallet_server_url,
+            pin,
+        )
+        .await
+        {
+            tracing::warn!(
+                target: "wallet-bootstrap",
+                "Birthday tree backfill skipped (sync will rebuild later): {e}"
+            );
+        }
     } else if config.birthday_height == 0 {
         // Fresh create (birthday 0): jump scan cursor to LWD tip — new wallets
         // have no history; walking genesis → tip only causes trial-decrypt /
@@ -168,3 +187,95 @@ fn parse_network(network: &str) -> Network {
         _ => Network::Testnet, // testnet + localnet share Testnet address encoding
     }
 }
+
+/// Stream note commitments from genesis to `birthday - 1` and append them to
+/// the Money Merkle tree without trial decryption.
+///
+/// This ensures that spend proofs generated after a birthday restore use a
+/// Merkle root that includes ALL on-chain commitments, not just the ones
+/// from `birthday..tip`. Without this backfill, the local tree root diverges
+/// from the on-chain anchor and `tx.calculate_fee` / broadcast fails with
+/// an invalid anchor error.
+///
+/// Non-fatal: if LWD is unreachable the sync engine will rebuild the tree
+/// on next successful connection (via `rebuild_money_tree_to_height`).
+async fn backfill_money_tree_to_birthday(
+    drk: &Drk,
+    birthday: u32,
+    lwd_url: &str,
+    tls_pin: Option<[u8; 32]>,
+) -> Result<(), String> {
+    use darkfi_sdk::crypto::MerkleNode;
+    use darkfi_sdk::pasta::group::ff::PrimeField;
+    use darkfi_sdk::pasta::pallas;
+    use std::collections::{BTreeMap, HashSet};
+
+    let end = birthday.saturating_sub(1);
+    if end == 0 {
+        return Ok(());
+    }
+
+    let client = LightwalletClient::from_endpoint_and_pin(lwd_url, tls_pin);
+
+    // Collect owned coin bytes so we can mark them in the tree (edge case:
+    // a restored wallet may have coins discovered by a previous partial sync).
+    let owned: HashSet<Vec<u8>> = match drk.get_coins(false).await {
+        Ok(coins) => coins
+            .into_iter()
+            .map(|(own, _, _, _, _)| own.coin.to_bytes().to_vec())
+            .collect(),
+        Err(_) => HashSet::new(),
+    };
+
+    let mut tree = crate::sync::empty_money_tree();
+    let mut appended = 0u64;
+
+    const CHUNK: u32 = 4096;
+    let mut start = 1u32;
+    while start <= end {
+        let chunk_end = end.min(start.saturating_add(CHUNK.saturating_sub(1)));
+        let updates = client.get_note_commitments(start, chunk_end).await?;
+
+        let mut by_h: BTreeMap<u32, Vec<Vec<u8>>> = BTreeMap::new();
+        for (height, coins) in updates {
+            if height >= start && height <= chunk_end {
+                by_h.entry(height).or_default().extend(coins);
+            }
+        }
+
+        for height in start..=chunk_end {
+            for coin_bytes in by_h.get(&height).map(|v| v.as_slice()).unwrap_or(&[]) {
+                if coin_bytes.len() != 32 {
+                    continue;
+                }
+                let mut repr = [0u8; 32];
+                repr.copy_from_slice(coin_bytes);
+                let Some(base) = Option::<pallas::Base>::from(pallas::Base::from_repr(repr))
+                else {
+                    continue;
+                };
+                tree.append(MerkleNode::from(base));
+                appended += 1;
+                if owned.contains(coin_bytes) {
+                    let _ = tree.mark();
+                }
+            }
+        }
+
+        start = chunk_end.saturating_add(1);
+        if start == 0 {
+            break; // overflow guard
+        }
+    }
+
+    drk.cache
+        .insert_merkle_trees(&[(drk::money::SLED_MERKLE_TREES_MONEY, &tree)])
+        .map_err(|e| format!("persist backfilled Money tree: {e}"))?;
+    let _ = drk.cache.sled_db.flush();
+
+    tracing::info!(
+        target: "wallet-bootstrap",
+        "Birthday backfill complete: appended {appended} pre-birthday commitments (1..={end})"
+    );
+    Ok(())
+}

rust/darkfi-mobile-ffi/src/sync.rs

@@ -1410,7 +1410,7 @@ pub(crate) fn load_received_memo(drk: &drk::Drk, tx_hash: &str) -> Option<String
         .filter(|s| !s.is_empty())
 }
 
-fn empty_money_tree() -> darkfi_sdk::crypto::MerkleTree {
+pub(crate) fn empty_money_tree() -> darkfi_sdk::crypto::MerkleTree {
     use darkfi_sdk::crypto::{MerkleNode, MerkleTree};
     use darkfi_sdk::pasta::group::ff::Field;
     use darkfi_sdk::pasta::pallas;