chore: merge develop with conflicts

Author: federico-stacks

.github/workflows/ci.yml

@@ -369,5 +369,6 @@ jobs:
         with:
           file: ${{ env.REPORT_FILES_DIR }}/code-coverage-report.${{ env.REPORT_FILES_EXT }}
           compare-ref: ${{ github.base_ref }} # defaults to master if this isn't supplied
+          build-number: ${{ github.run_id }}-${{ github.run_attempt }} # include run attempt in build so that repeated CI job runs don't cause a "job already closed" error on upload
           fail-on-error: true
-      
+      

changelog.d/6964-block-response-data-failed-txid.changed

@@ -0,0 +1 @@
+`BlockResponseData` version bumped from 4 to 5 to include the new `failed_txid` field. Older signers that don't send this field are handled gracefully via backwards-compatible deserialization.

changelog.d/6964-miners-exclude-failed-txs.added

@@ -0,0 +1 @@
+Miners now track `failed_txid` from signer block rejections. When a blocking minority (>30%) of signers report the same transaction as failed, the miner excludes it from the next block proposal. A new `ProblematicTransaction` validation reject code distinguishes genuinely broken transactions (permanently blacklisted from the mempool) from context-dependent failures like deadline exceeded (excluded until a successful block only).

changelog.d/7160-fix-apply-evaluated.fixed

@@ -0,0 +1 @@
+Improved performance for `fold`, `map`, and `filter` Clarity functions

clarity/src/vm/functions/sequences.rs

@@ -89,8 +89,13 @@ pub fn special_filter(
             sequence = Value::Sequence(
                 sequence_data
                     .try_retain(&mut |value: Value| -> Result<bool, VmExecutionError> {
-                        let filter_eval =
-                            apply_evaluated(&function, vec![value], exec_state, invoke_ctx)?;
+                        let filter_eval = apply_evaluated(
+                            &function,
+                            vec![value],
+                            exec_state,
+                            invoke_ctx,
+                            context,
+                        )?;
                         if let Value::Bool(include) = filter_eval {
                             Ok(include)
                         } else {
@@ -163,7 +168,13 @@ pub fn special_fold(
         let element = element_result.map_err(|_| {
             VmInternalError::Expect("ERROR: Invalid sequence data successfully constructed".into())
         })?;
-        acc = apply_evaluated(&function, vec![element, acc], exec_state, invoke_ctx)?;
+        acc = apply_evaluated(
+            &function,
+            vec![element, acc],
+            exec_state,
+            invoke_ctx,
+            context,
+        )?;
     }
     Ok(acc)
 }
@@ -226,7 +237,7 @@ pub fn special_map(
                 })?;
             call_args.push(value);
         }
-        let res = apply_evaluated(&function, call_args, exec_state, invoke_ctx)?;
+        let res = apply_evaluated(&function, call_args, exec_state, invoke_ctx, context)?;
         mapped_results.push(res);
     }
 

clarity/src/vm/mod.rs

@@ -414,24 +414,39 @@ pub fn apply(
 /// Like [`apply`], but takes pre-evaluated [`Value`]s, skipping the `eval` + `clone_with_cost`
 /// round-trip for every argument.
 ///
-/// `fold` and `map` already have the element value and accumulator as owned `Value`s; wrapping
+/// `fold`, `map`, and `filter` already have the element values as owned `Value`s; wrapping
 /// them in `SymbolicExpression::atom_value` just to have `eval` clone them back out wastes N
 /// allocations per step.  This function performs the same recursion/stack/memory bookkeeping
 /// as `apply` while bypassing the eval pass entirely.
+///
+/// For [`CallableType::SpecialFunction`]s (e.g. comparison operators `>=`, `<=`, `<`, `>`,
+/// or boolean operators `and`, `or`), the values are wrapped back into
+/// `SymbolicExpression::atom_value` so the special function can evaluate them normally
+/// with `eval`.
 pub fn apply_evaluated(
     function: &CallableType,
     args: Vec<Value>,
     exec_state: &mut ExecutionState,
     invoke_ctx: &InvocationContext,
+    context: &LocalContext,
 ) -> Result<Value, VmExecutionError> {
     let (identifier, track_recursion) = check_call_preconditions(function, exec_state)?;
-    // SpecialFunctions require unevaluated SymbolicExpressions. They cannot appear as
-    // fold/map step functions after type-checking, so this branch is unreachable in practice.
-    if matches!(function, CallableType::SpecialFunction(..)) {
-        return Err(RuntimeCheckErrorKind::Unreachable(
-            "apply_evaluated: SpecialFunction cannot receive pre-evaluated args".into(),
-        )
-        .into());
+
+    // SpecialFunctions require unevaluated SymbolicExpressions. They evaluate their own
+    // arguments (e.g. short-circuit in `and`/`or`). Wrap the pre-evaluated Values back
+    // into atom_value expressions so the special function dispatch works correctly.
+    // This path is hit when built-in operators like >=, <=, <, >, and, or are used as
+    // step functions in fold/map/filter. Note: In this case it works like `apply`.
+    if let CallableType::SpecialFunction(_, function) = function {
+        let sym_args: Vec<SymbolicExpression> = args
+            .into_iter()
+            .map(SymbolicExpression::atom_value)
+            .collect();
+        exec_state.call_stack.insert(&identifier, track_recursion);
+        let mut resp = function(&sym_args, exec_state, invoke_ctx, context);
+        add_stack_trace(&mut resp, exec_state);
+        exec_state.call_stack.remove(&identifier, track_recursion)?;
+        return resp;
     }
 
     let mut used_memory = 0;

clarity/src/vm/tests/sequences.rs

@@ -1309,3 +1309,96 @@ fn test_expected_list_application() {
         RuntimeCheckErrorKind::Unreachable("Expected list application".to_string()).into();
     assert_eq!(e, execute(test1).unwrap_err());
 }
+
+#[test]
+fn test_map_with_special_functions() {
+    // special function: >=
+    let test = "(map >= (list 3 1 2) (list 1 2 2))";
+    let expected = Value::list_from(vec![
+        Value::Bool(true),  // (>= 3 1)
+        Value::Bool(false), // (>= 1 2)
+        Value::Bool(true),  // (>= 2 2)
+    ])
+    .unwrap();
+    assert_eq!(expected, execute(test).unwrap().unwrap());
+
+    // special function: <=
+    let test = "(map <= (list 3 1 2) (list 1 2 2))";
+    let expected = Value::list_from(vec![
+        Value::Bool(false), // (<= 3 1)
+        Value::Bool(true),  // (<= 1 2)
+        Value::Bool(true),  // (<= 2 2)
+    ])
+    .unwrap();
+    assert_eq!(expected, execute(test).unwrap().unwrap());
+
+    // special function: <
+    let test = "(map < (list 1 5 2) (list 3 3 3))";
+    let expected = Value::list_from(vec![
+        Value::Bool(true),  // (< 1 3)
+        Value::Bool(false), // (< 5 3)
+        Value::Bool(true),  // (< 2 3)
+    ])
+    .unwrap();
+    assert_eq!(expected, execute(test).unwrap().unwrap());
+
+    // special function: >
+    let test = "(map > (list 5 1 3) (list 3 3 3))";
+    let expected = Value::list_from(vec![
+        Value::Bool(true),  // (> 5 3)
+        Value::Bool(false), // (> 1 3)
+        Value::Bool(false), // (> 3 3)
+    ])
+    .unwrap();
+    assert_eq!(expected, execute(test).unwrap().unwrap());
+}
+
+#[test]
+fn test_fold_with_special_functions() {
+    // special function: and
+    //   step 1: (and true true) => true
+    //   step 2: (and false true) => false
+    let test = "(fold and (list true false) true)";
+    assert_eq!(Value::Bool(false), execute(test).unwrap().unwrap());
+
+    // special function: or
+    //   step 1: (or false false) => false
+    //   step 2: (or true false) => true
+    let test = "(fold or (list false true) false)";
+    assert_eq!(Value::Bool(true), execute(test).unwrap().unwrap());
+
+    // Comparison SpecialFunctions (>=, <=, <, >) return bool so they can't
+    // fold over multi-element lists (type mismatch after step 1). Verify
+    // they work for a single-element list where only one step executes.
+
+    // special function: >=
+    let test = "(fold >= (list 3) 1)";
+    assert_eq!(Value::Bool(true), execute(test).unwrap().unwrap());
+
+    // special function: <=
+    let test = "(fold <= (list 1) 3)";
+    assert_eq!(Value::Bool(true), execute(test).unwrap().unwrap());
+
+    // special function: <
+    let test = "(fold < (list 1) 3)";
+    assert_eq!(Value::Bool(true), execute(test).unwrap().unwrap());
+
+    // special function: >
+    let test = "(fold > (list 3) 1)";
+    assert_eq!(Value::Bool(true), execute(test).unwrap().unwrap());
+}
+
+#[test]
+fn test_filter_with_special_functions() {
+    // special function: and
+    //   keeps elements where (and elem) => true
+    let test = "(filter and (list true false true false))";
+    let expected = Value::list_from(vec![Value::Bool(true), Value::Bool(true)]).unwrap();
+    assert_eq!(expected, execute(test).unwrap().unwrap());
+
+    // special function: or
+    //   keeps elements where (or elem) => true
+    let test = "(filter or (list false true false true))";
+    let expected = Value::list_from(vec![Value::Bool(true), Value::Bool(true)]).unwrap();
+    assert_eq!(expected, execute(test).unwrap().unwrap());
+}