THROWAWAY: Finding 3 revert-check, no-fail-fast -- DO NOT MERGE

.config/nextest.toml

@@ -8,6 +8,11 @@
 # per-test override here rather than removing this backstop.
 [profile.default]
 slow-timeout = { period = "60s", terminate-after = 3 }
+# THROWAWAY (Finding 3 revert-check diagnostic, never merged): CI invokes cargo nextest
+# run WITHOUT --profile, so [profile.ci] settings never applied here -- fail-fast must
+# live on [profile.default] to disable it, so a deliberately reverted enforcement does
+# not cancel the rest of the suite before the other under-test config.rs tests run.
+fail-fast = false
 
 # CI runs `cargo llvm-cov nextest` with `--retries 2`; the same backstop must apply there so a hang
 # on CI is terminated identically to a local run.

crates/dig-node-service/src/lib.rs

@@ -103,6 +103,12 @@ pub mod peers;
 /// The passthrough relay guard (#1997): whether this node relays an unimplemented method to an
 /// upstream, and the bring-up probe that proves an upstream is not this node itself. See [`relay`].
 pub mod relay;
+/// The node's PEER-SIDE reward claim loop (DIG-Network/dig_ecosystem#3251): discovers the
+/// reward distributors covering the `(store_id, root)`s this node mirrors and submits
+/// `InitiatePayout` on a jittered cadence, default 24h. The other half of the reward-distributor
+/// lifecycle from `dig_node_core::rewards` (#3250, the funder-side prover, a sibling lane). See
+/// [`rewards_claim`].
+pub mod rewards_claim;
 pub mod rpc;
 /// The offline `wallet export-seed` rescue command: a local read of this node's
 /// encrypted seed file. Adds no network surface, and is removed with node-side custody.

crates/dig-node-service/src/rewards_claim/cadence.rs

@@ -0,0 +1,85 @@
+//! Claim cadence + jitter (SPEC §8.6): the peer's own setting, never curried on the distributor,
+//! and jittered so a network of peers on the default does not converge on one minute of the day.
+//!
+//! The jitter SOURCE is injected — never a global RNG or clock read directly — so the schedule is
+//! deterministic under test.
+
+/// SPEC §8.6: the minimum jitter spread every peer MUST apply.
+pub const CLAIM_JITTER_SECONDS_DEFAULT: u64 = 3_600;
+
+/// Supplies the jitter offset for one scheduling decision. A production implementation draws from
+/// the OS CSPRNG; tests inject a fixed or sequenced value.
+pub trait JitterSource: Send + Sync {
+    /// An offset in `0..=bound` seconds.
+    fn jitter_seconds(&self, bound: u64) -> u64;
+}
+
+/// A jitter source that always returns the same value — for deterministic tests.
+pub struct FixedJitter(pub u64);
+
+impl JitterSource for FixedJitter {
+    fn jitter_seconds(&self, bound: u64) -> u64 {
+        self.0.min(bound)
+    }
+}
+
+/// The next cadence interval, in seconds: `cadence_seconds + jitter`, where `jitter` is drawn from
+/// `[0, jitter_seconds]` via the injected source (SPEC §8.6). `jitter_seconds` is a lower bound on
+/// the SPREAD available to the source, not a fixed addition — a source that always returns `0`
+/// still produces a schedule within the required bound, just at its floor.
+#[must_use]
+pub fn next_interval_seconds(
+    cadence_seconds: u64,
+    jitter_seconds: u64,
+    source: &dyn JitterSource,
+) -> u64 {
+    let offset = source.jitter_seconds(jitter_seconds);
+    cadence_seconds.saturating_add(offset)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn interval_is_cadence_plus_a_bounded_jitter() {
+        let cadence = 86_400;
+        let jitter_bound = 3_600;
+
+        let at_floor = next_interval_seconds(cadence, jitter_bound, &FixedJitter(0));
+        assert_eq!(at_floor, cadence);
+
+        let at_ceiling = next_interval_seconds(cadence, jitter_bound, &FixedJitter(jitter_bound));
+        assert_eq!(at_ceiling, cadence + jitter_bound);
+
+        // A source that tries to exceed the bound is clamped by the source contract itself
+        // (FixedJitter here), and the composed interval never exceeds cadence + jitter_seconds.
+        let over = next_interval_seconds(cadence, jitter_bound, &FixedJitter(jitter_bound * 10));
+        assert!(over <= cadence + jitter_bound);
+        assert!(over >= cadence);
+    }
+
+    /// ACCEPTANCE 8 (part) — a config setting a cadence OTHER than the default is honoured by the
+    /// scheduling function, not silently overridden back to `CLAIM_CADENCE_SECONDS_DEFAULT`.
+    #[test]
+    fn a_non_default_configured_cadence_is_honoured() {
+        let cfg = super::super::config::RewardsClaimConfig {
+            enabled: true,
+            cadence_seconds: 12_000,
+            jitter_seconds: 500,
+            max_fee_mojos: 1,
+            max_cycle_fee_budget_mojos: 10,
+            rotation_cursor: None,
+            ..super::super::config::RewardsClaimConfig::default()
+        };
+        let interval =
+            next_interval_seconds(cfg.cadence_seconds, cfg.jitter_seconds, &FixedJitter(0));
+        assert_eq!(
+            interval, 12_000,
+            "configured cadence, not the 86_400 default"
+        );
+        let interval_at_ceiling =
+            next_interval_seconds(cfg.cadence_seconds, cfg.jitter_seconds, &FixedJitter(500));
+        assert_eq!(interval_at_ceiling, 12_500);
+    }
+}