Merge branch 'develop' of https://github.com/stacks-network/stacks-core into feat/ignore-old-proposals-node

Author: jferrant

.github/workflows/bitcoin-tests.yml

@@ -144,6 +144,7 @@ jobs:
           - tests::nakamoto_integrations::mock_mining
           - tests::nakamoto_integrations::multiple_miners
           - tests::nakamoto_integrations::follower_bootup_across_multiple_cycles
+          - tests::nakamoto_integrations::nakamoto_lockup_events
           - tests::nakamoto_integrations::utxo_check_on_startup_panic
           - tests::nakamoto_integrations::utxo_check_on_startup_recover
           - tests::nakamoto_integrations::v3_signer_api_endpoint

.github/workflows/clippy.yml

@@ -37,4 +37,4 @@ jobs:
         uses: actions-rs/clippy-check@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          args: -p libstackerdb -p stacks-signer -p pox-locking --no-deps --tests --all-features -- -D warnings
+          args: -p libstackerdb -p stacks-signer -p pox-locking -p clarity -p libsigner --no-deps --tests --all-features -- -D warnings

clarity/src/vm/analysis/analysis_db.rs

@@ -50,11 +50,11 @@ impl<'a> AnalysisDatabase<'a> {
         self.begin();
         let result = f(self).or_else(|e| {
             self.roll_back()
-                .map_err(|e| CheckErrors::Expects(format!("{e:?}")).into())?;
+                .map_err(|e| CheckErrors::Expects(format!("{e:?}")))?;
             Err(e)
         })?;
         self.commit()
-            .map_err(|e| CheckErrors::Expects(format!("{e:?}")).into())?;
+            .map_err(|e| CheckErrors::Expects(format!("{e:?}")))?;
         Ok(result)
     }
 
@@ -130,9 +130,9 @@ impl<'a> AnalysisDatabase<'a> {
                     .map_err(|_| CheckErrors::Expects("Bad data deserialized from DB".into()))
             })
             .transpose()?
-            .and_then(|mut x| {
+            .map(|mut x| {
                 x.canonicalize_types(epoch);
-                Some(x)
+                x
             }))
     }
 

clarity/src/vm/analysis/arithmetic_checker/mod.rs

@@ -68,7 +68,7 @@ impl std::fmt::Display for Error {
     }
 }
 
-impl<'a> ArithmeticOnlyChecker<'a> {
+impl ArithmeticOnlyChecker<'_> {
     pub fn check_contract_cost_eligible(contract_analysis: &mut ContractAnalysis) {
         let is_eligible = ArithmeticOnlyChecker::run(contract_analysis).is_ok();
         contract_analysis.is_cost_contract_eligible = is_eligible;

clarity/src/vm/analysis/contract_interface_builder/mod.rs

@@ -276,7 +276,7 @@ impl ContractInterfaceFunction {
                     outputs: ContractInterfaceFunctionOutput {
                         type_f: match function_type {
                             FunctionType::Fixed(FixedFunction { returns, .. }) => {
-                                ContractInterfaceAtomType::from_type_signature(&returns)
+                                ContractInterfaceAtomType::from_type_signature(returns)
                             }
                             _ => return Err(CheckErrors::Expects(
                                 "Contract functions should only have fixed function return types!"
@@ -287,7 +287,7 @@ impl ContractInterfaceFunction {
                     },
                     args: match function_type {
                         FunctionType::Fixed(FixedFunction { args, .. }) => {
-                            ContractInterfaceFunctionArg::from_function_args(&args)
+                            ContractInterfaceFunctionArg::from_function_args(args)
                         }
                         _ => {
                             return Err(CheckErrors::Expects(

clarity/src/vm/analysis/errors.rs

@@ -207,10 +207,10 @@ impl CheckErrors {
     /// Does this check error indicate that the transaction should be
     /// rejected?
     pub fn rejectable(&self) -> bool {
-        match &self {
-            CheckErrors::SupertypeTooLarge | CheckErrors::Expects(_) => true,
-            _ => false,
-        }
+        matches!(
+            self,
+            CheckErrors::SupertypeTooLarge | CheckErrors::Expects(_)
+        )
     }
 }
 
@@ -323,7 +323,7 @@ pub fn check_arguments_at_most<T>(expected: usize, args: &[T]) -> Result<(), Che
     }
 }
 
-fn formatted_expected_types(expected_types: &Vec<TypeSignature>) -> String {
+fn formatted_expected_types(expected_types: &[TypeSignature]) -> String {
     let mut expected_types_joined = format!("'{}'", expected_types[0]);
 
     if expected_types.len() > 2 {

clarity/src/vm/analysis/mod.rs

@@ -17,7 +17,6 @@
 pub mod analysis_db;
 pub mod arithmetic_checker;
 pub mod contract_interface_builder;
-#[allow(clippy::result_large_err)]
 pub mod errors;
 pub mod read_only_checker;
 pub mod trait_checker;
@@ -52,7 +51,7 @@ pub fn mem_type_check(
     epoch: StacksEpochId,
 ) -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> {
     let contract_identifier = QualifiedContractIdentifier::transient();
-    let mut contract = build_ast_with_rules(
+    let contract = build_ast_with_rules(
         &contract_identifier,
         snippet,
         &mut (),
@@ -68,7 +67,7 @@ pub fn mem_type_check(
     let cost_tracker = LimitedCostTracker::new_free();
     match run_analysis(
         &QualifiedContractIdentifier::transient(),
-        &mut contract,
+        &contract,
         &mut analysis_db,
         false,
         cost_tracker,
@@ -120,6 +119,7 @@ pub fn type_check(
     .map_err(|(e, _cost_tracker)| e)
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn run_analysis(
     contract_identifier: &QualifiedContractIdentifier,
     expressions: &[SymbolicExpression],

clarity/src/vm/analysis/read_only_checker/mod.rs

@@ -50,7 +50,7 @@ pub struct ReadOnlyChecker<'a, 'b> {
     clarity_version: ClarityVersion,
 }
 
-impl<'a, 'b> AnalysisPass for ReadOnlyChecker<'a, 'b> {
+impl AnalysisPass for ReadOnlyChecker<'_, '_> {
     fn run_pass(
         epoch: &StacksEpochId,
         contract_analysis: &mut ContractAnalysis,
@@ -250,13 +250,12 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> {
         Ok(result)
     }
 
-    /// Checks the native function application of the function named by the
-    /// string `function` to `args` to determine whether it is read-only
-    /// compliant.
+    /// Checks the native function application of the function named by the string `function`
+    /// to `args` to determine whether it is read-only compliant.
     ///
     /// - Returns `None` if there is no native function named `function`.
-    /// - If there is such a native function, returns `true` iff this function application is
-    /// read-only.
+    /// - If there is such a native function, returns `true` iff this function
+    ///   application is read-only.
     ///
     /// # Errors
     /// - Contract parsing errors
@@ -414,15 +413,15 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> {
         }
     }
 
-    /// Checks the native and user-defined function applications implied by `expressions`. The
-    /// first expression is used as the function name, and the tail expressions are used as the
-    /// arguments.
+    /// Checks the native and user-defined function applications implied by `expressions`.
+    ///
+    /// The first expression is used as the function name, and the tail expressions are used as the arguments.
     ///
     /// Returns `true` iff the function application is read-only.
     ///
     /// # Errors
     /// - `CheckErrors::NonFunctionApplication` if there is no first expression, or if the first
-    /// expression is not a `ClarityName`.
+    ///   expression is not a `ClarityName`.
     /// - `CheckErrors::UnknownFunction` if the first expression does not name a known function.
     fn check_expression_application_is_read_only(
         &mut self,

clarity/src/vm/analysis/type_checker/contexts.rs

@@ -92,7 +92,7 @@ impl TypeMap {
     }
 }
 
-impl<'a> TypingContext<'a> {
+impl TypingContext<'_> {
     pub fn new(epoch: StacksEpochId, clarity_version: ClarityVersion) -> TypingContext<'static> {
         TypingContext {
             epoch,

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

@@ -55,7 +55,7 @@ impl FunctionType {
             | StacksEpochId::Epoch30
             | StacksEpochId::Epoch31 => self.check_args_2_1(accounting, args, clarity_version),
             StacksEpochId::Epoch10 => {
-                return Err(CheckErrors::Expects("Epoch10 is not supported".into()).into())
+                Err(CheckErrors::Expects("Epoch10 is not supported".into()).into())
             }
         }
     }
@@ -81,17 +81,14 @@ impl FunctionType {
                 self.check_args_by_allowing_trait_cast_2_1(db, clarity_version, func_args)
             }
             StacksEpochId::Epoch10 => {
-                return Err(CheckErrors::Expects("Epoch10 is not supported".into()).into())
+                Err(CheckErrors::Expects("Epoch10 is not supported".into()).into())
             }
         }
     }
 }
 
 fn is_reserved_word_v3(word: &str) -> bool {
-    match word {
-        "block-height" => true,
-        _ => false,
-    }
+    word == "block-height"
 }
 
 /// Is this a reserved word that should trigger an analysis error for the given