- fix: resolve stack overflow in casper debug tests (F1R3FLY-io#305, F1R3FLY-io#306);

* - fix: resolve stack overflow in casper debug tests (F1R3FLY-io#305, F1R3FLY-io#306);

* - delete --relese from CI;

* - fix i64 overflow in put_and_collect_partial_data_from_the_stor test;

* - create unit tests for deep rholang recursion;
- increase stack red zone for correct stacker work;

Author: NazarY-DevBrother

.cargo/config.toml

@@ -2,6 +2,15 @@
 #
 # This file contains build configuration and compiler flags for the entire workspace.
 
+[env]
+# Set minimum thread stack size to 8MB for test threads.
+# The Rholang interpreter uses deep async recursion (eval → produce/consume → dispatch → eval)
+# via Box::pin patterns. In debug builds, each recursion level consumes significantly more
+# stack space (~1-2KB) than in release builds (~100-200 bytes) due to lack of inlining and
+# unoptimized async state machines. The default 2MB stack overflows during normal test execution.
+# See: https://github.com/F1R3FLY-io/f1r3node/issues/305
+RUST_MIN_STACK = "8388608"
+
 [build]
 # Enable native CPU features for gxhash (requires AES and SSE2 intrinsics)
 rustflags = ["-C", "target-cpu=native"]

.github/workflows/build-test-and-deploy.yml

@@ -156,7 +156,7 @@ jobs:
         run: |
           mkdir -p /tmp/test-logs
           pushd ${{ matrix.tests }}
-          cargo test --release 2>&1 | tee /tmp/test-logs/${{ matrix.tests }}-test-output.txt
+          cargo test 2>&1 | tee /tmp/test-logs/${{ matrix.tests }}-test-output.txt
           TEST_EXIT_CODE=${PIPESTATUS[0]}
           popd
           exit $TEST_EXIT_CODE

Cargo.lock

@@ -43,6 +43,7 @@ imbl = "7"
 regex = "1.12"
 async-trait = "0.1"
 metrics = "0.24"
+stacker = "0.1"
 
 [profile.dev]
 debug = true

Cargo.toml

@@ -0,0 +1,74 @@
+use crate::genesis::contracts::test_util::TestUtil;
+use crate::util::rholang::resources::{generate_scope_id, mk_test_rnode_store_manager_shared};
+use casper::rust::genesis::genesis::Genesis;
+use crypto::rust::hash::blake2b512_random::Blake2b512Random;
+use models::rhoapi::{BindPattern, ListParWithRandom};
+use rholang::rust::build::compile_rholang_source::CompiledRholangSource;
+use rholang::rust::interpreter::matcher::r#match::Matcher;
+use rholang::rust::interpreter::rho_runtime::create_runtime_from_kv_store;
+use rspace_plus_plus::rspace::r#match::Match;
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+
+async fn eval_rholang_code(code: &str, timeout: Duration) -> Result<(), String> {
+    let scope_id = generate_scope_id();
+    let mut kvs_manager = mk_test_rnode_store_manager_shared(scope_id);
+    let r_store = kvs_manager
+        .r_space_stores()
+        .await
+        .map_err(|e| format!("Failed to create RSpaceStore: {}", e))?;
+
+    let matcher =
+        Arc::new(Box::new(Matcher::default()) as Box<dyn Match<BindPattern, ListParWithRandom>>);
+
+    let runtime = create_runtime_from_kv_store(
+        r_store,
+        Genesis::non_negative_mergeable_tag_name(),
+        true,
+        &mut vec![],
+        matcher,
+        rholang::rust::interpreter::external_services::ExternalServices::noop(),
+    )
+    .await;
+
+    let rand = Blake2b512Random::create_from_length(128);
+
+    match tokio::time::timeout(
+        timeout,
+        TestUtil::eval(code, &runtime, HashMap::new(), rand),
+    )
+    .await
+    {
+        Ok(Ok(())) => Ok(()),
+        Ok(Err(e)) => Err(format!("Interpreter error: {:?}", e)),
+        Err(_) => Err(format!("Timeout of {:?} expired", timeout)),
+    }
+}
+
+/// Regression test for https://github.com/F1R3FLY-io/f1r3node/issues/305
+///
+/// shortslow.rho: direct recursive contract that calls itself 32768 times.
+/// Without StackGrowingFuture, this causes stack overflow in debug builds.
+#[tokio::test]
+async fn deep_recursion_shortslow_should_not_stackoverflow() {
+    let code = CompiledRholangSource::load_source("shortslow.rho")
+        .expect("Failed to load shortslow.rho");
+
+    let result = eval_rholang_code(&code, Duration::from_secs(300)).await;
+    assert!(result.is_ok(), "shortslow deep recursion failed: {:?}", result.err());
+}
+
+/// Regression test for https://github.com/F1R3FLY-io/f1r3node/issues/306
+///
+/// longslow.rho: sends a 32768-char string to a channel, reads its length,
+/// then recurses that many times. This exercises produce/consume + string ops
+/// in addition to deep recursion, matching the exact integration test scenario.
+#[tokio::test]
+async fn deep_recursion_longslow_should_not_stackoverflow() {
+    let code = CompiledRholangSource::load_source("longslow.rho")
+        .expect("Failed to load longslow.rho");
+
+    let result = eval_rholang_code(&code, Duration::from_secs(300)).await;
+    assert!(result.is_ok(), "longslow deep recursion failed: {:?}", result.err());
+}

casper/tests/genesis/contracts/deep_recursion_spec.rs

@@ -21,6 +21,7 @@ pub mod stack_spec;
 pub mod standard_deploys_spec;
 pub mod timeout_result_collector_spec;
 pub mod tree_hash_map_spec;
+pub mod deep_recursion_spec;
 
 // See casper/src/test/scala/coop/rchain/casper/genesis/contracts/package.scala
 pub const GENESIS_TEST_TIMEOUT: Duration = Duration::from_secs(60);

casper/tests/genesis/contracts/mod.rs

@@ -268,7 +268,13 @@ mod tests {
                 // Note: Fixed the bug here - using max() instead of min()
                 let k_min = *keys.iter().min().unwrap();
                 let k_max = *keys.iter().max().unwrap(); // Fixed: was keys.min in Scala
-                let k_avg = k_max - k_min / 2;
+                // Old formula: k_max - k_min / 2 — when k_min is negative, subtracting
+                // a negative becomes addition, which overflows i64. In --release Rust
+                // silently wraps and the test "passes" with an incorrect result.
+                // In debug mode — panic.
+                // New formula: computes the average without overflow for any i64 values,
+                // even at extreme ranges.
+                let k_avg = k_min / 2 + k_max / 2 + (k_min % 2 + k_max % 2) / 2;
 
                 let expected_filtered: HashMap<i64, String> = expected
                     .iter()

casper/tests/util/in_memory_key_value_store_spec.rs

@@ -53,6 +53,7 @@ typed-arena = "2.0.2"
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 metrics = { workspace = true }
+stacker = { workspace = true }
 reqwest = { version = "0.11", features = ["json"] }
 serde_json = { workspace = true }
 

rholang/Cargo.toml

@@ -41,6 +41,8 @@ impl CompiledRholangSource {
             format!("src/test/resources/{}", filepath),
             format!("../casper/src/main/resources/{}", filepath),
             format!("../casper/src/test/resources/{}", filepath),
+            format!("rholang/examples/{}", filepath),
+            format!("../rholang/examples/{}", filepath),
         ];
 
         for path in &possible_paths {

rholang/src/rust/build/compile_rholang_source.rs

@@ -28,8 +28,10 @@ use prost::Message;
 use rspace_plus_plus::rspace::util::unpack_option_with_peek;
 use std::collections::{BTreeMap, BTreeSet};
 use std::collections::{HashMap, HashSet};
+use std::future::Future;
 use std::pin::Pin;
 use std::sync::{Arc, RwLock};
+use std::task::{Context, Poll};
 
 use crate::rust::interpreter::accounting::costs::{
     add_cost, bytes_to_hex_cost, diff_cost, hex_to_bytes_cost, interpolate_cost, keys_method_cost,
@@ -57,6 +59,46 @@ use super::unwrap_option_safe;
 use super::util::GeneratedMessage;
 use models::rust::pathmap_crate_type_mapper::PathMapCrateTypeMapper;
 
+/// Minimum remaining stack space (in bytes) before growing.
+/// When the current stack has less than this amount remaining, a new stack segment is allocated.
+// 128 KB is too small: a single recursion frame in the Rholang interpreter
+// (eval → produce/consume → dispatch → eval) consumes more than 128 KB between
+// stacker checks, so the overflow happens before stacker can grow the stack.
+const STACK_RED_ZONE: usize = 1024 * 1024; // 1 MB
+
+/// Size of each new stack segment allocated when the red zone is reached.
+const STACK_GROW_SIZE: usize = 2 * 1024 * 1024; // 2 MB
+
+/// A Future wrapper that dynamically grows the thread stack during polling.
+///
+/// The Rholang interpreter uses deep async recursion: eval → produce/consume → dispatch → eval.
+/// Each poll of this recursive future chain adds stack frames. In debug builds, unoptimized
+/// async state machines consume ~1-2KB per recursion level, causing stack overflow with the
+/// default 2MB thread stack.
+///
+/// `StackGrowingFuture` wraps each recursive entry point (eval, produce, consume, dispatch).
+/// On each poll, `stacker::maybe_grow` checks remaining stack space. If below STACK_RED_ZONE,
+/// it allocates a new STACK_GROW_SIZE segment and runs the poll there. This allows arbitrarily
+/// deep Rholang recursion (e.g., longslow.rho with 32768 iterations) without stack overflow.
+///
+/// See: https://github.com/F1R3FLY-io/f1r3node/issues/305
+/// See: https://github.com/F1R3FLY-io/f1r3node/issues/306
+struct StackGrowingFuture<F> {
+    inner: F,
+}
+
+impl<F: Future> Future for StackGrowingFuture<F> {
+    type Output = F::Output;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // SAFETY: Structural pin projection on a single-field struct with no Drop impl.
+        // `inner` is only accessed through this pinned projection, and StackGrowingFuture
+        // does not implement Unpin when F doesn't, preserving pin guarantees.
+        let inner = unsafe { self.map_unchecked_mut(|s| &mut s.inner) };
+        stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || inner.poll(cx))
+    }
+}
+
 /**
  * Reduce is the interface for evaluating Rholang expressions.
  */
@@ -95,7 +137,7 @@ impl DebruijnInterpreter {
         env: &'a Env<Par>,
         rand: Blake2b512Random,
     ) -> Pin<Box<dyn std::future::Future<Output = Result<(), InterpreterError>> + std::marker::Send + 'a>> {
-        Box::pin(self.eval_inner(par, env, rand))
+        Box::pin(StackGrowingFuture { inner: self.eval_inner(par, env, rand) })
     }
 
     async fn eval_inner(
@@ -212,7 +254,7 @@ impl DebruijnInterpreter {
         data: ListParWithRandom,
         persistent: bool,
     ) -> Pin<Box<dyn std::future::Future<Output = Result<DispatchType, InterpreterError>> + std::marker::Send + 'a>> {
-        Box::pin(self.produce_inner(chan, data, persistent))
+        Box::pin(StackGrowingFuture { inner: self.produce_inner(chan, data, persistent) })
     }
 
     async fn produce_inner(
@@ -283,7 +325,7 @@ impl DebruijnInterpreter {
         persistent: bool,
         peek: bool,
     ) -> Pin<Box<dyn std::future::Future<Output = Result<DispatchType, InterpreterError>> + std::marker::Send + 'a>> {
-        Box::pin(self.consume_inner(binds, body, persistent, peek))
+        Box::pin(StackGrowingFuture { inner: self.consume_inner(binds, body, persistent, peek) })
     }
 
     async fn consume_inner(
@@ -543,7 +585,7 @@ impl DebruijnInterpreter {
         is_replay: bool,
         previous_output: Vec<Par>,
     ) -> Pin<Box<dyn std::future::Future<Output = Result<DispatchType, InterpreterError>> + std::marker::Send + 'a>> {
-        Box::pin(self.dispatch_inner(continuation, data_list, is_replay, previous_output))
+        Box::pin(StackGrowingFuture { inner: self.dispatch_inner(continuation, data_list, is_replay, previous_output) })
     }
 
     async fn dispatch_inner(