dashpay · lklimek · May 6, 2026 · May 5, 2026 · May 5, 2026 · May 5, 2026
@@ -34,12 +34,18 @@
   - packages/rs-platform-version/**
   - packages/rs-platform-versioning/**
   - packages/rs-dpp/**
-  # Exclude Rust test files — they don't affect WASM builds
-  - '!packages/rs-dpp/**/tests.rs'
-  - '!packages/rs-dpp/**/tests/**'
-  - '!packages/rs-dpp/**/test_helpers/**'
-  - '!packages/rs-dpp/**/test_utils.rs'
-  - '!packages/rs-dpp/**/test_utils/**'
+  # NOTE: do not add `!packages/rs-dpp/**/tests.rs` style negation
+  # patterns here. The dispatcher in `tests.yml` runs these filters
+  # via `dorny/paths-filter@v3` with the default
+  # `predicate-quantifier: some`, under which each pattern (including
+  # `!`-prefixed ones) is OR'd independently. A `!` pattern then
+  # "matches" every file that doesn't match the negated path — i.e.
+  # virtually every file in the repo — which trips this filter on
+  # Swift-only / Rust-only changes and cascades through every other
+  # filter that aliases `*wasm-dpp` (dapi, dapi-client, wallet-lib,
+  # dash, dashmate, platform-test-suite, …). Cheaper to over-trigger
+  # the WASM tests on rs-dpp test-only edits than to mis-trigger
+  # half the JS test matrix on every PR.
 
 '@dashevo/wasm-dpp2': &wasm-dpp2
   - packages/wasm-dpp2/**
@@ -96,13 +102,10 @@ dashmate:
   - packages/rs-platform-version/**
   - packages/rs-dash-platform-macros/**
   - packages/dapi-grpc/**
-  # Exclude Rust test files — they don't affect WASM builds
-  - '!packages/rs-drive-proof-verifier/**/tests.rs'
-  - '!packages/rs-drive-proof-verifier/**/tests/**'
-  - '!packages/rs-sdk/**/tests.rs'
-  - '!packages/rs-sdk/**/tests/**'
-  - '!packages/rs-dapi-client/**/tests.rs'
-  - '!packages/rs-dapi-client/**/tests/**'
+  # NOTE: do not add `!path` negation patterns here — see the long
+  # explanation on `@dashevo/wasm-dpp` above. Same `dorny/paths-filter@v3`
+  # + `predicate-quantifier: some` interaction trips this filter on
+  # unrelated changes and cascades into every consumer (`*wasm-sdk`).
 
 '@dashevo/evo-sdk': &evo-sdk
   - packages/js-evo-sdk/**

@@ -42,7 +42,7 @@ jobs:
     if: ${{ github.event_name == 'workflow_dispatch' || github.event_name == 'schedule' || !github.event.pull_request.draft }}
     runs-on: ubuntu-24.04
     outputs:
-      js-packages: ${{ steps.override.outputs.js-packages || steps.filter-js.outputs.changes }}
+      js-packages: ${{ steps.override.outputs.js-packages || steps.prune-pr-matrix.outputs.js-packages || steps.filter-js.outputs.changes }}
       js-packages-direct: ${{ steps.override.outputs.js-packages-direct || steps.filter-js-direct.outputs.changes }}
       rs-packages: ${{ steps.override.outputs.rs-packages || steps.filter-rs.outputs.changes }}
       rs-workflows-changed: ${{ steps.filter-rs-workflows.outputs.rs-workflows }}
@@ -124,6 +124,35 @@ jobs:
               - packages/rs-sdk/**
               - packages/rs-sdk-ffi/**
 
+      # Drop @dashevo/wasm-dpp from the JS test matrix on
+      # `pull_request` events so the heaviest entry in the matrix
+      # only runs on the nightly schedule + manual
+      # `workflow_dispatch`. @dashevo/wasm-dpp2 stays on the PR
+      # path — it's a separate, lighter package that should be
+      # exercised on every PR. Cascading consumers
+      # (`dapi-client`, `wallet-lib`, `dash`, `dashmate`,
+      # `platform-test-suite`, `evo-sdk`) also keep running on PRs:
+      # their JS test code exercises behavior on top of wasm-dpp's
+      # already-built artifact, and `tests-build-js.yml` runs
+      # `yarn build` across the whole workspace so the wasm-dpp
+      # output is still compiled and linkable for them — just not
+      # test-driven on the PR critical path. To force wasm-dpp
+      # tests on a specific PR, use the `Run workflow`
+      # (workflow_dispatch) button on the Actions tab — that path
+      # goes through the `override` step below and runs every JS
+      # package.
+      - name: Skip wasm-dpp tests on pull_request (nightly-only)
+        id: prune-pr-matrix
+        if: ${{ github.event_name == 'pull_request' }}
+        run: |
+          set -eo pipefail
+          raw='${{ steps.filter-js.outputs.changes }}'
+          pruned=$(echo "$raw" | jq -c 'map(select(. != "@dashevo/wasm-dpp"))')
+          echo "js-packages=$pruned" >> "$GITHUB_OUTPUT"
+          echo "Pruned wasm-dpp from PR matrix:"
+          echo "  before: $raw"
+          echo "  after:  $pruned"
+
       - name: Override all outputs for workflow_dispatch
         id: override
         if: ${{ github.event_name == 'workflow_dispatch' }}

@@ -155,6 +155,13 @@ export default function getBaseConfigFactory() {
           },
         },
         indexes: [],
+        // BIP158 cfilter index + NODE_COMPACT_FILTERS service bit.
+        // Default-on across every preset so dashmate-managed nodes
+        // are BIP157 SPV-friendly out of the box. Operators who
+        // can't spare the cfilter index disk overhead (~10% of
+        // chain size on mainnet) can flip this off via
+        // `dashmate config set core.compactFilters false`.
+        compactFilters: true,
       },
       platform: {
         quorumList: {

@@ -36,6 +36,14 @@ export default function getLocalConfigFactory(getBaseConfig) {
         zmq: {
           port: 49998,
         },
+        // Mirrors the `core.compactFilters: true` set on the base
+        // config; restated explicitly here because the local
+        // preset is the canonical surface where dev BIP157 SPV
+        // clients (e.g. the swift-sdk iOS example app pointed at
+        // `local_seed`) need cfilter sync to work, and we want
+        // that requirement to survive any future flip of the base
+        // default.
+        compactFilters: true,
       },
       dashmate: {
         helper: {

@@ -1413,6 +1413,20 @@ export default function getConfigFileMigrationsFactory(homeDir, defaultConfigs)
             const isLocal = options.network === NETWORK_LOCAL || name === 'local';
             const isTestnet = options.network === NETWORK_TESTNET || name === 'testnet';
 
+            // Flip `core.compactFilters` to true for every config —
+            // pre-3.1.0 configs predate the field entirely (template
+            // emitted nothing, dashcore left the cfilter index off),
+            // so a missing-or-false value here always means
+            // "inherited the old implicit-off default" rather than
+            // "user explicitly opted out". The base config now
+            // ships with this flag on; this backfill brings every
+            // already-set-up cluster up to that line so the iOS
+            // BIP157 SPV flow against `local_seed` (and any other
+            // dashmate node) works without manual editing.
+            if (options.core) {
+              options.core.compactFilters = true;
+            }
+
             if (options.platform?.drive?.tenderdash?.docker
               && defaultConfig.has('platform.drive.tenderdash.docker.image')) {
               options.platform.drive.tenderdash.docker.image = defaultConfig

@@ -487,6 +487,14 @@ export default {
           description: 'List of core indexes to enable. `platform.enable`, '
             + ' `core.masternode.enable`, and `core.insight.enabled` add indexes dynamically',
         },
+        compactFilters: {
+          type: 'boolean',
+          description: 'Build the BIP158 cfilter index and advertise '
+            + 'NODE_COMPACT_FILTERS to peers, so BIP157 SPV clients can sync '
+            + 'filter headers + filters from this node. Defaults to true on '
+            + 'every preset; flip to false to skip the cfilter index '
+            + '(~10% chain-size disk overhead on mainnet).',
+        },
       },
       required: ['docker', 'p2p', 'rpc', 'zmq', 'spork', 'masternode', 'miner', 'devnet', 'log',
         'indexes', 'insight'],

@@ -69,6 +69,17 @@ spentindex=1
 {{~}}
 {{?}}
 
+# BIP157/158 compact block filters. Building the cfilter index plus
+# advertising NODE_COMPACT_FILTERS lets BIP157 SPV clients sync
+# headers + filters from this node. Off by default (mainnet/testnet
+# usage doesn't justify the disk + CPU overhead); enabled on the
+# `local` preset where the chain is tiny and the iOS dev flow needs
+# filter sync against dashmate's `local_seed` to test the wallet.
+{{? it.core.compactFilters }}
+blockfilterindex=basic
+peerblockfilters=1
+{{?}}
+
 # ZeroMQ notifications
 zmqpubrawtx=tcp://0.0.0.0:{{=it.core.zmq.port}}
 zmqpubrawtxlock=tcp://0.0.0.0:{{=it.core.zmq.port}}

@@ -101,7 +101,7 @@ pub unsafe extern "C" fn platform_wallet_manager_create_wallet_from_seed(
     };
 
     let option = PLATFORM_WALLET_MANAGER_STORAGE.with_item(manager_handle, |manager| {
-        runtime().block_on(manager.create_wallet_from_seed_bytes(network, seed, accounts))
+        runtime().block_on(manager.create_wallet_from_seed_bytes(network, seed, accounts, None))
     });
     let result = unwrap_option_or_return!(option);
     let wallet = unwrap_result_or_return!(result);
@@ -139,7 +139,12 @@ pub unsafe extern "C" fn platform_wallet_manager_create_wallet_from_mnemonic(
     };
 
     let option = PLATFORM_WALLET_MANAGER_STORAGE.with_item(manager_handle, |manager| {
-        runtime().block_on(manager.create_wallet_from_mnemonic(mnemonic_str, network, accounts))
+        runtime().block_on(manager.create_wallet_from_mnemonic(
+            mnemonic_str,
+            network,
+            accounts,
+            None,
+        ))
     });
     let result = unwrap_option_or_return!(option);
     let wallet = unwrap_result_or_return!(result);

@@ -60,6 +60,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             Network::Testnet,
             seed_bytes,
             WalletAccountCreationOptions::Default,
+            None,
         )
         .await?;
 

@@ -56,11 +56,23 @@ impl<P: PlatformWalletPersistence + 'static> PlatformWalletManager<P> {
     /// [`parse_mnemonic_any_language`]). For passphrase-only flows or
     /// out-of-band seed material, derive the seed externally and use
     /// [`Self::create_wallet_from_seed_bytes`].
+    ///
+    /// `birth_height_override` controls SPV's compact-filter scan
+    /// window for the new wallet. `None` (the default for fresh
+    /// wallets) seeds the birth height to SPV's current confirmed
+    /// header tip, so the scan window is `[H_now, ∞)` — anything
+    /// funded before init is invisible. `Some(0)` requests a full
+    /// historical scan from genesis (use sparingly — expensive on
+    /// long-lived chains, but required when an address may have
+    /// received funds before the wallet was first registered).
+    /// `Some(h)` pins the scan start to a specific block height,
+    /// useful when a known funding block is on record.
     pub async fn create_wallet_from_mnemonic(
         &self,
         mnemonic_phrase: &str,
         network: Network,
         accounts: WalletAccountCreationOptions,
+        birth_height_override: Option<u32>,
     ) -> Result<Arc<PlatformWallet>, PlatformWalletError> {
         let mnemonic = parse_mnemonic_any_language(mnemonic_phrase)
             .map_err(|e| PlatformWalletError::WalletCreation(format!("Invalid mnemonic: {}", e)))?;
@@ -70,35 +82,64 @@ impl<P: PlatformWalletPersistence + 'static> PlatformWalletManager<P> {
                 e
             ))
         })?;
-        self.register_wallet(wallet).await
+        self.register_wallet(wallet, birth_height_override).await
     }
 
     /// Create a PlatformWallet from raw seed bytes, initialize persisted
     /// state, register it with the manager and return an `Arc` handle.
+    ///
+    /// See [`Self::create_wallet_from_mnemonic`] for the
+    /// `birth_height_override` semantics. `None` keeps the
+    /// pre-existing behaviour (scan from current SPV tip forward);
+    /// `Some(h)` is for callers that need to see funding deposited
+    /// before the wallet was registered (e.g. a long-lived bank
+    /// address pre-funded with testnet duffs).
     pub async fn create_wallet_from_seed_bytes(
         &self,
         network: Network,
         seed_bytes: [u8; 64],
         accounts: WalletAccountCreationOptions,
+        birth_height_override: Option<u32>,
     ) -> Result<Arc<PlatformWallet>, PlatformWalletError> {
         let wallet = Wallet::from_seed_bytes(seed_bytes, network, accounts).map_err(|e| {
             PlatformWalletError::WalletCreation(format!(
                 "Failed to create wallet from seed bytes: {}",
                 e
             ))
         })?;
-        self.register_wallet(wallet).await
+        self.register_wallet(wallet, birth_height_override).await
     }
 
     /// Register a pre-built `Wallet` with the manager: insert into the
     /// `WalletManager`, build a `PlatformWallet` handle, load persisted
     /// state, and return an `Arc` to the managed wallet.
+    ///
+    /// `birth_height_override` flows through to both the in-memory
+    /// `ManagedWalletInfo` sync checkpoint and the persisted
+    /// `WalletMetadataEntry` so the SPV scan window is consistent
+    /// across restarts. See [`Self::create_wallet_from_mnemonic`] for
+    /// the contract.
     #[allow(clippy::type_complexity)]
     async fn register_wallet(
         &self,
         wallet: Wallet,
+        birth_height_override: Option<u32>,
     ) -> Result<Arc<PlatformWallet>, PlatformWalletError> {
-        let wallet_info = ManagedWalletInfo::from_wallet(&wallet, 0);
+        // Birth height resolution: explicit override wins; otherwise
+        // fall back to SPV's confirmed header tip (default for fresh
+        // wallets — they only need to see funding from now on); 0 if
+        // SPV isn't running yet.
+        let birth_height: u32 = match birth_height_override {
+            Some(h) => h,
+            None => self
+                .spv_manager
+                .sync_progress()
+                .await
+                .and_then(|p| p.headers().ok().map(|h| h.tip_height()))
+                .unwrap_or(0),
+        };
+
+        let wallet_info = ManagedWalletInfo::from_wallet(&wallet, birth_height);
 
         let balance = Arc::new(WalletBalance::new());
 
@@ -192,17 +233,10 @@ impl<P: PlatformWalletPersistence + 'static> PlatformWalletManager<P> {
         // the persister is a best-effort channel, not a source of
         // truth in steady state.
 
-        // Birth height = SPV's confirmed header tip if SPV is running,
-        // otherwise 0 (caller can bump it later when SPV catches up).
-        // 0 means "scan from genesis", which is safe-correct for
-        // fresh wallets.
-        let birth_height: u32 = self
-            .spv_manager
-            .sync_progress()
-            .await
-            .and_then(|p| p.headers().ok().map(|h| h.tip_height()))
-            .unwrap_or(0);
-
+        // `birth_height` was resolved at the top of `register_wallet`
+        // and seeded into `ManagedWalletInfo`; reuse it here so the
+        // persisted `WalletMetadataEntry` agrees with the in-memory
+        // sync checkpoint.
         let mut registration_changeset = PlatformWalletChangeSet {
             wallet_metadata: Some(WalletMetadataEntry {
                 network: self.sdk.network,

@@ -233,6 +233,17 @@ impl SpvRuntime {
         Some(client.sync_progress().await)
     }
 
+    /// The [`PlatformEventManager`] this runtime dispatches SPV events
+    /// through. Exposed so consumers (e.g. the e2e framework) can
+    /// register additional [`crate::events::PlatformEventHandler`]s
+    /// after construction — for example, to observe
+    /// `SyncEvent::ManagerError` while waiting for mn-list sync so
+    /// hard-stalls surface immediately instead of burning the full
+    /// timeout.
+    pub fn event_manager(&self) -> &Arc<PlatformEventManager> {
+        &self.event_manager
+    }
+
     /// Clear all persisted SPV storage (headers, filters, state).
     ///
     /// The SPV client must be running to perform this operation.