Merge branch 'develop' of https://github.com/stacks-network/stacks-core into feat/variable-lookup-by-ref

Author: jacinta-stacks

.github/workflows/ci.yml

@@ -234,3 +234,21 @@ jobs:
       - create-cache
       - check-release
     uses: ./.github/workflows/epoch-tests.yml
+
+  ## Trigger Codecov report manually once all tests are done
+  ## This is done in concert with codecov.yml having notify: manual_trigger: true set
+  ## See: https://docs.codecov.com/docs/notifications#preventing-notifications-until-youre-ready-to-send-notifications
+  trigger-codecov-report:
+    if: ${{ always() && !cancelled() }}
+    name: Trigger Codecov Report
+    runs-on: ubuntu-latest
+    needs:
+      - stacks-core-tests
+      - bitcoin-tests
+      - p2p-tests
+      - epoch-tests
+    steps:
+      - name: Codecov Send Notifications
+        uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
+        with:
+          run_command: "send-notifications"

CHANGELOG.md

@@ -5,7 +5,7 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the versioning scheme outlined in the [README.md](README.md).
 
-## [Unreleased]
+## [3.3.0.0.6]
 
 ### Added
 
@@ -16,13 +16,15 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - Added `marf_compress` as a node configuration parameter to enable MARF compression feature ([#6811](https://github.com/stacks-network/stacks-core/pull/6811))
 - Effective in epoch 3.4 `contract-call?`s can accept a constant as the contract to be called
 - Added post-condition enhancements for epoch 3.4 (SIP-040): `Originator` post-condition mode (`0x03`) and NFT `MAY SEND` condition code (`0x12`), including serialization support and epoch-gated validation/enforcement.
+- Disabled `at-block` starting from Epoch 3.4 (see SIP-042). New contracts referencing `at-block` are rejected during static analysis. Existing contracts that invoke it will fail at runtime with an `AtBlockUnavailable` error.
 
 ### Fixed
 
 - Improved the cost-tracking for `from-consensus-buff?`, effective in epoch 3.4, so that when an empty buffer is passed, users will see a `none` result, rather than a confusing runtime error.
 - Resolved several cases where a mock-miner would stop mining
 - /v2/pox endpoint now returns the `pox_ustx_threshold` stored in the reward set instead of a live computed value, which incorrectly accounts for STX locked during the prepare phase, after the reward set has been set.
 - Signer protocol version negotiation now properly handles downgrades based on majority consensus, not just upgrades
+- The sortition DB now tracks canonical Stacks tip by its burn view, allowing it to recover from a chain freeze if the Bitcoin block upon which the ongoing tenure is based is orphened before the last tenure block is processed.
 
 ### Changed
 

clarity-types/src/errors/analysis.rs

@@ -498,6 +498,8 @@ pub enum StaticCheckErrorKind {
     WriteAttemptedInReadOnly,
     /// `at-block` closure must be read-only but contains write operations.
     AtBlockClosureMustBeReadOnly,
+    /// `at-block` is not available in this epoch.
+    AtBlockUnavailable,
 
     // contract post-conditions
     /// Post-condition expects a list of asset allowances but received invalid input.
@@ -611,13 +613,25 @@ pub enum RuntimeCheckErrorKind {
     /// Referenced function is not defined in the current scope.
     /// The `String` wraps the non-existent function name.
     UndefinedFunction(String),
+    /// `at-block` is not available in this epoch.
+    AtBlockUnavailable,
 
     // Argument counts
     /// Incorrect number of arguments provided to a function.
     /// The first `usize` represents the expected count, and the second represents the actual count.
     IncorrectArgumentCount(usize, usize),
 
     // Traits
+    /// Referenced trait is not defined or cannot be found.
+    /// The `String` wraps the non-existent trait name.
+    /// This is only reachable at runtime via contracts deployed with Clarity 1 as its
+    /// static analysis is not as strict as later clarity versions.
+    TraitReferenceUnknown(String),
+    /// Referenced method does not exist in the specified trait.
+    /// The first `String` wraps the trait name, and the second wraps the method name.
+    /// This is only reachable at runtime via contracts deployed with Clarity 1 as its
+    /// static analysis is not as strict as later clarity versions.
+    TraitMethodUnknown(String, String),
     /// Invalid implementation of a trait method.
     /// The first `String` wraps the trait name, and the second wraps the method name.
     BadTraitImplementation(String, String),
@@ -1175,6 +1189,7 @@ impl DiagnosableError for StaticCheckErrorKind {
             StaticCheckErrorKind::TooManyFunctionParameters(found, allowed) => format!("too many function parameters specified: found {found}, the maximum is {allowed}"),
             StaticCheckErrorKind::WriteAttemptedInReadOnly => "expecting read-only statements, detected a writing operation".into(),
             StaticCheckErrorKind::AtBlockClosureMustBeReadOnly => "(at-block ...) closures expect read-only statements, but detected a writing operation".into(),
+            StaticCheckErrorKind::AtBlockUnavailable => "(at-block ...) is not available in this epoch".into(),
             StaticCheckErrorKind::BadTokenName => "expecting an token name as an argument".into(),
             StaticCheckErrorKind::DefineNFTBadSignature => "(define-asset ...) expects an asset name and an asset identifier type signature as arguments".into(),
             StaticCheckErrorKind::NoSuchNFT(asset_name) => format!("tried to use asset function with a undefined asset ('{asset_name}')"),

clarity/fuzz/fuzz_targets/fuzz_sanitize.rs

@@ -245,7 +245,7 @@ pub fn strict_admits(me: &TypeSignature, x: &ClarityValue) -> Result<bool, Runti
         }
         TypeSignature::CallableType(_)
         | TypeSignature::ListUnionType(_)
-        | TypeSignature::TraitReferenceType(_) => Err(RuntimeCheckErrorKind::Unreachable(
+        | TypeSignature::TraitReferenceType(_) => Err(RuntimeCheckErrorKind::TraitReferenceUnknown(
             "Trait reference unknown".into(),
         )),
     }

clarity/fuzz/fuzz_targets/fuzz_value_sanitize.rs

@@ -251,7 +251,7 @@ pub fn strict_admits(me: &TypeSignature, x: &ClarityValue) -> Result<bool, Runti
         }
         TypeSignature::CallableType(_)
         | TypeSignature::ListUnionType(_)
-        | TypeSignature::TraitReferenceType(_) => Err(RuntimeCheckErrorKind::Unreachable(
+        | TypeSignature::TraitReferenceType(_) => Err(RuntimeCheckErrorKind::TraitReferenceUnknown(
             "Trait reference unknown".into(),
         )),
     }

clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs

@@ -132,6 +132,9 @@ fn check_special_at_block(
     context: &TypingContext,
 ) -> Result<TypeSignature, StaticCheckError> {
     check_argument_count(2, args)?;
+    if !checker.epoch.supports_at_block() {
+        return Err(StaticCheckErrorKind::AtBlockUnavailable.into());
+    }
     checker.type_check_expects(&args[0], context, &TypeSignature::BUFFER_32)?;
     checker.type_check(&args[1], context)
 }

clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs

@@ -927,12 +927,51 @@ fn test_at_block() {
     for (good_test, expected) in good.iter() {
         assert_eq!(
             expected,
-            &format!("{}", type_check_helper(good_test).unwrap())
+            &format!(
+                "{}",
+                type_check_helper_version(
+                    good_test,
+                    ClarityVersion::Clarity4,
+                    StacksEpochId::Epoch33
+                )
+                .unwrap()
+            )
         );
     }
 
     for (bad_test, expected) in bad.iter() {
-        assert_eq!(*expected, *type_check_helper(bad_test).unwrap_err().err);
+        assert_eq!(
+            *expected,
+            *type_check_helper_version(bad_test, ClarityVersion::Clarity4, StacksEpochId::Epoch33)
+                .unwrap_err()
+                .err
+        );
+    }
+
+    assert_eq!(
+        StaticCheckErrorKind::AtBlockUnavailable,
+        *type_check_helper_version(
+            "(at-block (sha256 u0) u1)",
+            ClarityVersion::Clarity4,
+            StacksEpochId::Epoch34
+        )
+        .unwrap_err()
+        .err
+    );
+
+    let mut versions_gt_clarity4 = ClarityVersion::ALL.to_vec();
+    versions_gt_clarity4.retain(|version| *version > ClarityVersion::Clarity4);
+    for version in versions_gt_clarity4 {
+        assert_eq!(
+            StaticCheckErrorKind::UnknownFunction("at-block".to_string()),
+            *type_check_helper_version(
+                "(at-block (sha256 u0) u1)",
+                version,
+                StacksEpochId::latest()
+            )
+            .unwrap_err()
+            .err
+        );
     }
 }
 

clarity/src/vm/callables.rs

@@ -342,16 +342,16 @@ impl DefinedFunction {
         let trait_name = trait_identifier.name.to_string();
         let constraining_trait = contract_defining_trait
             .lookup_trait_definition(&trait_name)
-            .ok_or(RuntimeCheckErrorKind::Unreachable(format!(
-                "Trait reference unknown: {trait_name}"
-            )))?;
+            .ok_or(RuntimeCheckErrorKind::TraitReferenceUnknown(
+                trait_name.to_string(),
+            ))?;
         let expected_sig =
             constraining_trait
                 .get(&self.name)
-                .ok_or(RuntimeCheckErrorKind::Unreachable(format!(
-                    "Trait method unknown: {trait_name}.{}",
-                    self.name
-                )))?;
+                .ok_or(RuntimeCheckErrorKind::TraitMethodUnknown(
+                    trait_name.to_string(),
+                    self.name.to_string(),
+                ))?;
 
         let args = self.arg_types.to_vec();
         if !expected_sig.check_args_trait_compliance(epoch, args)? {

clarity/src/vm/docs/mod.rs

@@ -1470,7 +1470,9 @@ const AT_BLOCK: SpecialAPI = SpecialAPI {
     snippet: "at-block ${1:id-header-hash} ${2:expr}",
     output_type: "A",
     signature: "(at-block id-block-hash expr)",
-    description: "The `at-block` function evaluates the expression `expr` _as if_ it were evaluated at the end of the
+    description: "Removed in Epoch 3.4 (see SIP-042).
+
+The `at-block` function evaluates the expression `expr` _as if_ it were evaluated at the end of the
 block indicated by the _block-hash_ argument. The `expr` closure must be read-only.
 
 Note: The block identifying hash must be a hash returned by the `id-header-hash` block information

clarity/src/vm/functions/database.rs

@@ -188,6 +188,7 @@ pub fn special_contract_call(
                             .into());
                         }
 
+                        // If this check succeeds, the subsequent trait reference and method checks cannot fail
                         function_to_check.check_trait_expectations(
                             exec_state.epoch(),
                             &contract_context_defining_trait,
@@ -545,6 +546,9 @@ pub fn special_at_block(
     invoke_ctx: &InvocationContext,
     context: &LocalContext,
 ) -> Result<Value, VmExecutionError> {
+    if !exec_state.epoch().supports_at_block() {
+        return Err(RuntimeCheckErrorKind::AtBlockUnavailable.into());
+    }
     check_argument_count(2, args)?;
 
     runtime_cost(ClarityCostFunction::AtBlock, exec_state, 0)?;