Merge remote-tracking branch 'stacks-network/develop' into feat/shadow-marf

Author: jcnelson

.github/workflows/clippy.yml

@@ -42,3 +42,7 @@ jobs:
       - name: Clippy
         id: clippy
         run: cargo clippy-stacks
+
+      - name: Clippy Stackslib
+        id: clippy-stackslib
+        run: cargo clippy-stackslib

CHANGELOG.md

@@ -12,10 +12,12 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - Renamed `clarity-serialization` to `clarity-types`.
 - Add `stackerdb_timeout_secs` to miner config for limiting duration of StackerDB HTTP requests.
 - When determining a global transaction replay set, the state evaluator now uses a longest-common-prefix algorithm to find a replay set in the case where a single replay set has less than 70% of signer weight.
-- New endpoint /v3/tenures/blocks/ allowing retrieving the list of stacks blocks from a burn block
+- New endpoints /v3/tenures/blocks/, /v3/tenures/blocks/hash, /v3/tenures/blocks/height allowing retrieving the list of stacks blocks from a burn block
 - Creates epoch 3.3 and costs-4 in preparation for a hardfork to activate Clarity 4
 - Adds support for new Clarity 4 builtins (not activated until epoch 3.3):
   - `contract-hash?`
+  - `current-contract`
+  - `block-time`
   - `to-ascii?`
 - Added `contract_cost_limit_percentage` to the miner config file — sets the percentage of a block’s execution cost at which, if a large non-boot contract call would cause a BlockTooBigError, the miner will stop adding further non-boot contract calls and only include STX transfers and boot contract calls for the remainder of the block.
 
@@ -25,8 +27,9 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
   expressive (#6337)
 - Removed affirmation maps logic throughout, upgrading chainstate DB schema to 11 and burnchain DB schema to 3 (#6314)
 
-### Changed
+### Fixed
 
+- When running `stacks-inspect decode-tx`, print the correct version of the address (mainnet or testnet) based on the transaction passed in
 - When a contract deploy is analyzed, it will no longer throw a `CostError` when the contract contains an undefined top-level variable. Instead, it will throw a `UndefinedVariable` error.
 
 ## [3.2.0.0.1]

CONTRIBUTING.md

@@ -56,7 +56,7 @@ For an example of this process, see PRs
   test, module, function, etc.), each should be documented according
   to our [coding guidelines](#Coding-Guidelines).
 
-> [*] The Changelog focuses on product changes. A "major change" refers to updates that have a direct impact on the end user, such as introducing new features, modifying existing functionality, or optimizing runtime performance. 
+> [*] The Changelog focuses on product changes. A "major change" refers to updates that have a direct impact on the end user, such as introducing new features, modifying existing functionality, or optimizing runtime performance.
 On the other hand, changes that do not need to be reflected in the Changelog include code refactoring, writing tests, or automating processes, as these do not directly affect the user experience.
 
 ## Git Commit Messages
@@ -374,10 +374,10 @@ A test should be marked `#[ignore]` if:
 - **Integration tests need to be properly tagged** using [pinny-rs](https://github.com/BitcoinL2-Labs/pinny-rs/) crate. Tagging requires two fundamental steps:
   1. Define allowed tags in the package `Cargo.toml` file (if needed).
   2. Apply relevant tags to the tests, picking from the allowed set.
-  
+
   Then it will be possible to run tests with filtering based on the tags using `cargo test` and `cargo nextest` runner.
   > For more information and examples on how tagging works, refer to the [pinny-rs](https://github.com/BitcoinL2-Labs/pinny-rs/) readme.
-  
+
   Below the tag set currently defined with related purpose:
 
   | Tag             | Description                                  |
@@ -406,16 +406,26 @@ cargo fmt-stacks
 
 ## Clippy Warnings
 
-PRs will be checked against `clippy` and will _fail_ if any clippy warnings are generated.
-Unfortunately, not all existing clippy warnings have been addressed throughout stacks-core, so arguments must be passed via the command line. 
-Therefore, we handle `clippy` configurations using a Cargo alias: `cargo clippy-stacks`
+All PRs are checked with `clippy`, and the CI will **fail** if any warnings are raised.
+Because not all existing clippy warnings in `stacks-core` have been addressed, we use Cargo aliases to standardize how clippy is run across different parts of the codebase.
+
+Two commands are available:
 
-You can check what warnings need to be addressed locally via: 
+- `cargo clippy-stacks`
+  Runs clippy across the core packages of the repository (e.g. `stx-genesis`, `clarity`, `stacks-signer`, etc.).
+
+- `cargo clippy-stackslib`
+  Runs clippy specifically on the `stackslib` package, with a different configuration.
+
+To check warnings locally, run:
 
 ```bash
 cargo clippy-stacks
+cargo clippy-stackslib
 ```
 
+Make sure both commands pass before opening a pull request.
+
 ## Comments
 
 Comments are very important for the readability and correctness of the codebase. The purpose of comments is:
@@ -491,7 +501,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> {
     /// - Returns CheckErrors::WriteAttemptedInReadOnly if there is a read-only
     ///   violation, i.e. if some function marked read-only attempts to modify
     ///   the chainstate.
-    pub fn run(&mut self, contract_analysis: &ContractAnalysis) -> CheckResult<()>
+    pub fn run(&mut self, contract_analysis: &ContractAnalysis) -> Result<(), CheckError>
 ```
 
 This comment is considered positive because it explains the contract of the function in pseudo-code. Someone who understands the constructs mentioned could, e.g., write a test for this method from this description.

Cargo.lock

@@ -14,7 +14,7 @@ lazy_static = { workspace = true }
 regex = { version = "1", default-features = false }
 rusqlite = { workspace = true, optional = true }
 serde = { workspace = true }
-serde_json = { version = "1.0", default-features = false }
+serde_json = { version = "1.0", default-features = false, optional = true }
 serde_derive = { workspace = true }
 slog = { workspace = true }
 stacks_common = { package = "stacks-common", path = "../stacks-common", default-features = false }
@@ -28,7 +28,7 @@ default = []
 testing = []
 developer-mode = ["stacks_common/developer-mode"]
 slog_json = ["stacks_common/slog_json"]
-rusqlite = ["stacks_common/rusqlite", "dep:rusqlite"]
+rusqlite = ["stacks_common/rusqlite", "dep:rusqlite", "dep:serde_json"]
 
 # Wasm-specific features for easier configuration
 wasm-web = ["stacks_common/wasm-web"]

clarity-types/Cargo.toml

@@ -21,8 +21,6 @@ use crate::execution_cost::ExecutionCost;
 use crate::representations::SymbolicExpression;
 use crate::types::{TraitIdentifier, TupleTypeSignature, TypeSignature, Value};
 
-pub type CheckResult<T> = Result<T, CheckError>;
-
 /// What kind of syntax binding was found to be in error?
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum SyntaxBindingErrorType {
@@ -164,50 +162,44 @@ pub enum CheckErrors {
     // match errors
     BadMatchOptionSyntax(Box<CheckErrors>),
     BadMatchResponseSyntax(Box<CheckErrors>),
-    BadMatchInput(TypeSignature),
+    BadMatchInput(Box<TypeSignature>),
 
     // list typing errors
-    UnknownListConstructionFailure,
     ListTypesMustMatch,
     ConstructedListTooLarge,
 
     // simple type expectation mismatch
-    TypeError(TypeSignature, TypeSignature),
-    TypeLiteralError(TypeSignature, TypeSignature),
-    TypeValueError(TypeSignature, Value),
+    TypeError(Box<TypeSignature>, Box<TypeSignature>),
+    TypeValueError(Box<TypeSignature>, Box<Value>),
 
-    NoSuperType(TypeSignature, TypeSignature),
     InvalidTypeDescription,
     UnknownTypeName(String),
 
     // union type mismatch
-    UnionTypeError(Vec<TypeSignature>, TypeSignature),
-    UnionTypeValueError(Vec<TypeSignature>, Value),
-
-    ExpectedLiteral,
-    ExpectedOptionalType(TypeSignature),
-    ExpectedResponseType(TypeSignature),
-    ExpectedOptionalOrResponseType(TypeSignature),
-    ExpectedOptionalValue(Value),
-    ExpectedResponseValue(Value),
-    ExpectedOptionalOrResponseValue(Value),
+    UnionTypeError(Vec<TypeSignature>, Box<TypeSignature>),
+    UnionTypeValueError(Vec<TypeSignature>, Box<Value>),
+
+    ExpectedOptionalType(Box<TypeSignature>),
+    ExpectedResponseType(Box<TypeSignature>),
+    ExpectedOptionalOrResponseType(Box<TypeSignature>),
+    ExpectedOptionalValue(Box<Value>),
+    ExpectedResponseValue(Box<Value>),
+    ExpectedOptionalOrResponseValue(Box<Value>),
     CouldNotDetermineResponseOkType,
     CouldNotDetermineResponseErrType,
     CouldNotDetermineSerializationType,
     UncheckedIntermediaryResponses,
-    ExpectedContractPrincipalValue(Value),
+    ExpectedContractPrincipalValue(Box<Value>),
 
     CouldNotDetermineMatchTypes,
     CouldNotDetermineType,
 
     // Checker runtime failures
     TypeAlreadyAnnotatedFailure,
-    TypeAnnotationExpectedFailure,
     CheckerImplementationFailure,
 
     // Assets
     BadTokenName,
-    DefineFTBadSignature,
     DefineNFTBadSignature,
     NoSuchNFT(String),
     NoSuchFT(String),
@@ -220,7 +212,7 @@ pub enum CheckErrors {
 
     // tuples
     BadTupleFieldName,
-    ExpectedTuple(TypeSignature),
+    ExpectedTuple(Box<TypeSignature>),
     NoSuchTupleField(String, TupleTypeSignature),
     EmptyTuplesNotAllowed,
     BadTupleConstruction(String),
@@ -236,9 +228,9 @@ pub enum CheckErrors {
     DefineFunctionBadSignature,
     BadFunctionName,
     BadMapTypeDefinition,
-    PublicFunctionMustReturnResponse(TypeSignature),
+    PublicFunctionMustReturnResponse(Box<TypeSignature>),
     DefineVariableBadSignature,
-    ReturnTypesMustMatch(TypeSignature, TypeSignature),
+    ReturnTypesMustMatch(Box<TypeSignature>, Box<TypeSignature>),
 
     CircularReference(Vec<String>),
 
@@ -248,7 +240,7 @@ pub enum CheckErrors {
     PublicFunctionNotReadOnly(String, String),
     ContractAlreadyExists(String),
     ContractCallExpectName,
-    ExpectedCallableType(TypeSignature),
+    ExpectedCallableType(Box<TypeSignature>),
 
     // get-block-info? errors
     NoSuchBlockInfoProperty(String),
@@ -266,7 +258,7 @@ pub enum CheckErrors {
     // expect a function, or applying a function to a list
     NonFunctionApplication,
     ExpectedListApplication,
-    ExpectedSequence(TypeSignature),
+    ExpectedSequence(Box<TypeSignature>),
     MaxLengthOverflow,
 
     // let syntax
@@ -283,10 +275,9 @@ pub enum CheckErrors {
     RequiresAtLeastArguments(usize, usize),
     RequiresAtMostArguments(usize, usize),
     IncorrectArgumentCount(usize, usize),
-    IfArmsMustMatch(TypeSignature, TypeSignature),
-    MatchArmsMustMatch(TypeSignature, TypeSignature),
-    DefaultTypesMustMatch(TypeSignature, TypeSignature),
-    TooManyExpressions,
+    IfArmsMustMatch(Box<TypeSignature>, Box<TypeSignature>),
+    MatchArmsMustMatch(Box<TypeSignature>, Box<TypeSignature>),
+    DefaultTypesMustMatch(Box<TypeSignature>, Box<TypeSignature>),
     IllegalOrUnknownFunctionApplication(String),
     UnknownFunction(String),
 
@@ -295,15 +286,14 @@ pub enum CheckErrors {
     TraitReferenceUnknown(String),
     TraitMethodUnknown(String, String),
     ExpectedTraitIdentifier,
-    ImportTraitBadSignature,
     TraitReferenceNotAllowed,
     BadTraitImplementation(String, String),
     DefineTraitBadSignature,
     DefineTraitDuplicateMethod(String),
     UnexpectedTraitOrFieldReference,
     TraitBasedContractCallInReadOnly,
     ContractOfExpectsTrait,
-    IncompatibleTrait(TraitIdentifier, TraitIdentifier),
+    IncompatibleTrait(Box<TraitIdentifier>, Box<TraitIdentifier>),
 
     // strings
     InvalidCharactersDetected,
@@ -321,7 +311,7 @@ pub enum CheckErrors {
 
 #[derive(Debug, PartialEq)]
 pub struct CheckError {
-    pub err: CheckErrors,
+    pub err: Box<CheckErrors>,
     pub expressions: Option<Vec<SymbolicExpression>>,
     pub diagnostic: Diagnostic,
 }
@@ -341,7 +331,7 @@ impl CheckError {
     pub fn new(err: CheckErrors) -> CheckError {
         let diagnostic = Diagnostic::err(&err);
         CheckError {
-            err,
+            err: Box::new(err),
             expressions: None,
             diagnostic,
         }
@@ -456,7 +446,6 @@ impl From<CheckErrors> for String {
     }
 }
 
-#[allow(clippy::result_large_err)]
 pub fn check_argument_count<T>(expected: usize, args: &[T]) -> Result<(), CheckErrors> {
     if args.len() != expected {
         Err(CheckErrors::IncorrectArgumentCount(expected, args.len()))
@@ -465,7 +454,6 @@ pub fn check_argument_count<T>(expected: usize, args: &[T]) -> Result<(), CheckE
     }
 }
 
-#[allow(clippy::result_large_err)]
 pub fn check_arguments_at_least<T>(expected: usize, args: &[T]) -> Result<(), CheckErrors> {
     if args.len() < expected {
         Err(CheckErrors::RequiresAtLeastArguments(expected, args.len()))
@@ -474,7 +462,6 @@ pub fn check_arguments_at_least<T>(expected: usize, args: &[T]) -> Result<(), Ch
     }
 }
 
-#[allow(clippy::result_large_err)]
 pub fn check_arguments_at_most<T>(expected: usize, args: &[T]) -> Result<(), CheckErrors> {
     if args.len() > expected {
         Err(CheckErrors::RequiresAtMostArguments(expected, args.len()))
@@ -501,7 +488,6 @@ fn formatted_expected_types(expected_types: &[TypeSignature]) -> String {
 impl DiagnosableError for CheckErrors {
     fn message(&self) -> String {
         match &self {
-            CheckErrors::ExpectedLiteral => "expected a literal argument".into(),
             CheckErrors::SupertypeTooLarge => "supertype of two types is too large".into(),
             CheckErrors::Expects(s) => format!("unexpected interpreter behavior: {s}"),
             CheckErrors::BadMatchOptionSyntax(source) =>
@@ -512,7 +498,6 @@ impl DiagnosableError for CheckErrors {
                         source.message()),
             CheckErrors::BadMatchInput(t) =>
                 format!("match requires an input of either a response or optional, found input: '{t}'"),
-            CheckErrors::TypeAnnotationExpectedFailure => "analysis expected type to already be annotated for expression".into(),
             CheckErrors::CostOverflow => "contract execution cost overflowed cost counter".into(),
             CheckErrors::CostBalanceExceeded(a, b) => format!("contract execution cost exceeded budget: {a:?} > {b:?}"),
             CheckErrors::MemoryBalanceExceeded(a, b) => format!("contract execution cost exceeded memory budget: {a:?} > {b:?}"),
@@ -523,12 +508,9 @@ impl DiagnosableError for CheckErrors {
             CheckErrors::ValueOutOfBounds => "created a type which value size was out of defined bounds".into(),
             CheckErrors::TypeSignatureTooDeep => "created a type which was deeper than maximum allowed type depth".into(),
             CheckErrors::ExpectedName => "expected a name argument to this function".into(),
-            CheckErrors::NoSuperType(a, b) => format!("unable to create a supertype for the two types: '{a}' and '{b}'"),
-            CheckErrors::UnknownListConstructionFailure => "invalid syntax for list definition".into(),
             CheckErrors::ListTypesMustMatch => "expecting elements of same type in a list".into(),
             CheckErrors::ConstructedListTooLarge => "reached limit of elements in a sequence".into(),
             CheckErrors::TypeError(expected_type, found_type) => format!("expecting expression of type '{expected_type}', found '{found_type}'"),
-            CheckErrors::TypeLiteralError(expected_type, found_type) => format!("expecting a literal of type '{expected_type}', found '{found_type}'"),
             CheckErrors::TypeValueError(expected_type, found_value) => format!("expecting expression of type '{expected_type}', found '{found_value}'"),
             CheckErrors::UnionTypeError(expected_types, found_type) => format!("expecting expression of type {}, found '{}'", formatted_expected_types(expected_types), found_type),
             CheckErrors::UnionTypeValueError(expected_types, found_type) => format!("expecting expression of type {}, found '{}'", formatted_expected_types(expected_types), found_type),
@@ -593,21 +575,18 @@ impl DiagnosableError for CheckErrors {
             CheckErrors::IfArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'if' must match (got '{type_1}' and '{type_2}')"),
             CheckErrors::MatchArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'match' must match (got '{type_1}' and '{type_2}')"),
             CheckErrors::DefaultTypesMustMatch(type_1, type_2) => format!("expression types passed in 'default-to' must match (got '{type_1}' and '{type_2}')"),
-            CheckErrors::TooManyExpressions => "reached limit of expressions".into(),
             CheckErrors::IllegalOrUnknownFunctionApplication(function_name) => format!("use of illegal / unresolved function '{function_name}"),
             CheckErrors::UnknownFunction(function_name) => format!("use of unresolved function '{function_name}'"),
             CheckErrors::TraitBasedContractCallInReadOnly => "use of trait based contract calls are not allowed in read-only context".into(),
             CheckErrors::WriteAttemptedInReadOnly => "expecting read-only statements, detected a writing operation".into(),
             CheckErrors::AtBlockClosureMustBeReadOnly => "(at-block ...) closures expect read-only statements, but detected a writing operation".into(),
             CheckErrors::BadTokenName => "expecting an token name as an argument".into(),
-            CheckErrors::DefineFTBadSignature => "(define-token ...) expects a token name as an argument".into(),
             CheckErrors::DefineNFTBadSignature => "(define-asset ...) expects an asset name and an asset identifier type signature as arguments".into(),
             CheckErrors::NoSuchNFT(asset_name) => format!("tried to use asset function with a undefined asset ('{asset_name}')"),
             CheckErrors::NoSuchFT(asset_name) => format!("tried to use token function with a undefined token ('{asset_name}')"),
             CheckErrors::NoSuchTrait(contract_name, trait_name) => format!("use of unresolved trait {contract_name}.{trait_name}"),
             CheckErrors::TraitReferenceUnknown(trait_name) => format!("use of undeclared trait <{trait_name}>"),
             CheckErrors::TraitMethodUnknown(trait_name, func_name) => format!("method '{func_name}' unspecified in trait <{trait_name}>"),
-            CheckErrors::ImportTraitBadSignature => "(use-trait ...) expects a trait name and a trait identifier".into(),
             CheckErrors::BadTraitImplementation(trait_name, func_name) => format!("invalid signature for method '{func_name}' regarding trait's specification <{trait_name}>"),
             CheckErrors::ExpectedTraitIdentifier => "expecting expression of type trait identifier".into(),
             CheckErrors::UnexpectedTraitOrFieldReference => "unexpected use of trait reference or field".into(),