From 9035d7ce92e08094f3c8eee095b9dbb4a2c23349 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Fri, 24 Oct 2025 17:41:19 +0100 Subject: [PATCH 01/40] WIP: extract StaticCheckErrorKind from CheckErrorKind --- clarity-types/src/errors/analysis.rs | 1147 ++++++++++++++--- clarity-types/src/errors/mod.rs | 17 +- clarity-types/src/tests/types/mod.rs | 3 +- clarity-types/src/tests/types/signatures.rs | 22 +- clarity-types/src/types/mod.rs | 31 +- clarity-types/src/types/serialization.rs | 37 +- clarity-types/src/types/signatures.rs | 170 +-- clarity/src/vm/analysis/analysis_db.rs | 38 +- .../contract_interface_builder/mod.rs | 10 +- clarity/src/vm/analysis/errors.rs | 2 +- clarity/src/vm/analysis/mod.rs | 30 +- .../src/vm/analysis/read_only_checker/mod.rs | 35 +- .../vm/analysis/read_only_checker/tests.rs | 15 +- clarity/src/vm/analysis/trait_checker/mod.rs | 6 +- .../src/vm/analysis/trait_checker/tests.rs | 49 +- .../src/vm/analysis/type_checker/contexts.rs | 8 +- clarity/src/vm/analysis/type_checker/mod.rs | 6 +- .../analysis/type_checker/v2_05/contexts.rs | 8 +- .../src/vm/analysis/type_checker/v2_05/mod.rs | 117 +- .../type_checker/v2_05/natives/assets.rs | 58 +- .../type_checker/v2_05/natives/maps.rs | 28 +- .../type_checker/v2_05/natives/mod.rs | 127 +- .../type_checker/v2_05/natives/options.rs | 75 +- .../type_checker/v2_05/natives/sequences.rs | 65 +- .../type_checker/v2_05/tests/assets.rs | 80 +- .../type_checker/v2_05/tests/contracts.rs | 16 +- .../analysis/type_checker/v2_05/tests/mod.rs | 340 ++--- .../vm/analysis/type_checker/v2_1/contexts.rs | 10 +- .../src/vm/analysis/type_checker/v2_1/mod.rs | 213 +-- .../type_checker/v2_1/natives/assets.rs | 60 +- .../type_checker/v2_1/natives/maps.rs | 29 +- .../analysis/type_checker/v2_1/natives/mod.rs | 232 ++-- .../type_checker/v2_1/natives/options.rs | 75 +- .../type_checker/v2_1/natives/sequences.rs | 73 +- .../type_checker/v2_1/tests/assets.rs | 80 +- .../type_checker/v2_1/tests/contracts.rs | 123 +- .../analysis/type_checker/v2_1/tests/mod.rs | 631 ++++----- clarity/src/vm/analysis/types.rs | 8 +- clarity/src/vm/clarity.rs | 19 +- clarity/src/vm/errors.rs | 2 +- clarity/src/vm/functions/define.rs | 49 +- clarity/src/vm/functions/mod.rs | 3 +- clarity/src/vm/tests/variables.rs | 299 +++-- clarity/src/vm/types/signatures.rs | 131 +- .../chainstate/stacks/boot/contract_tests.rs | 4 +- ..._block_with_contract_call_success.snap.new | 160 --- stackslib/src/clarity_cli.rs | 5 +- .../src/clarity_vm/tests/analysis_costs.rs | 4 +- stackslib/src/clarity_vm/tests/contracts.rs | 18 +- 49 files changed, 2832 insertions(+), 1936 deletions(-) delete mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__append_block_with_contract_call_success.snap.new diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index 5efb0843f45..43269e5c6e7 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -136,16 +136,418 @@ impl SyntaxBindingError { } } -impl From for CheckErrorKind { +/// Converts a [`SyntaxBindingError`] into a [`StaticCheckErrorKind`]. +/// Used for propagating binding errors from +/// [`crate::vm::analysis::read_only_checker::ReadOnlyChecker::check_each_expression_is_read_only`] +impl From for StaticCheckErrorKind { fn from(e: SyntaxBindingError) -> Self { Self::BadSyntaxBinding(e) } } -/// Errors encountered during type-checking and analysis of Clarity contract code, ensuring -/// type safety, correct function signatures, and adherence to resource constraints. -/// These errors prevent invalid contracts from being deployed or executed, -/// halting analysis and failing the transaction or contract deployment. +/// Converts a [`SyntaxBindingError`] into a [`CommonCheckErrorKind`]. +/// Used for propagating binding errors from [`crate::vm::functions::handle_binding_list`], +/// which is utilized in both static and runtime analysis to ensure consistent error handling. +impl From for CommonCheckErrorKind { + fn from(e: SyntaxBindingError) -> Self { + CommonCheckErrorKind::BadSyntaxBinding(e) + } +} + +/// Internal set of error variants that are shared exclusively between static analysis (deployment) +// and runtime checking (execution), specifically for validation logic that is implemented in common +// code paths used by both. +/// +/// **This enum is strictly for internal use and is not a part of the public API.** +/// +/// All these variants represent errors that can arise *only* from code executed in both analysis and execution +/// contexts—such as argument count checks, type size limits, or shared cost tracking logic. If an error +/// may be triggered by either context via common logic, it lives here. +/// +/// Importantly, this enum does *not* cover all errors common to both analysis and execution. +/// There are other error shared error variants, but those are generated specifically by logic +/// that is unique to static analysis or unique to execution. These errors are defined separately +/// and do not pass through this enum. Only error cases that can possibly arise from a shared validation +/// flow will appear here. +/// +/// When a `CommonCheckErrorKind` is produced, it is always converted immediately into either a +/// [`StaticCheckErrorKind`] (when encountered during deployment analysis) *or* a +/// [`CheckErrorKind`] (when encountered at runtime). +#[derive(Debug, PartialEq)] +pub enum CommonCheckErrorKind { + // Cost checker errors + /// Arithmetic overflow in cost computation during type-checking, exceeding the maximum threshold. + CostOverflow, + /// Cumulative type-checking cost exceeds the allocated budget, indicating budget depletion. + /// The first `ExecutionCost` represents the total consumed cost, and the second represents the budget limit. + CostBalanceExceeded(ExecutionCost, ExecutionCost), + /// Memory usage during type-checking exceeds the allocated budget. + /// The first `u64` represents the total consumed memory, and the second represents the memory limit. + MemoryBalanceExceeded(u64, u64), + /// Failure in cost-tracking due to an unexpected condition or invalid state. + /// The `String` wraps the specific reason for the failure. + CostComputationFailed(String), + // Time checker errors + /// Type-checking time exceeds the allowed budget, halting analysis to ensure responsiveness. + ExecutionTimeExpired, + + /// Value exceeds the maximum allowed size for type-checking or serialization. + ValueTooLarge, + /// Value is outside the acceptable range for its type (e.g., integer bounds). + ValueOutOfBounds, + /// Type signature nesting depth exceeds the allowed limit during analysis. + TypeSignatureTooDeep, + /// Expected a name (e.g., variable, function) but found an invalid or missing token. + ExpectedName, + /// Supertype (e.g., trait or union) exceeds the maximum allowed size or complexity. + /// This error indicates a transaction would invalidate a block if included. + SupertypeTooLarge, + + // Unexpected interpreter behavior + /// Unexpected condition or failure in the type-checker, indicating a bug or invalid state. + /// This error indicates a transaction would invalidate a block if included. + Expects(String), + + // Type mismatch errors + /// Expected type does not match the actual type during analysis. + /// The first `Box` wraps the expected type, and the second wraps the actual type. + TypeError(Box, Box), + + /// Type description is invalid or malformed, preventing proper type-checking. + InvalidTypeDescription, + /// Referenced type name does not exist or is undefined. + /// The `String` wraps the non-existent type name. + UnknownTypeName(String), + + /// Could not determine the serialization type for a value during analysis. + CouldNotDetermineSerializationType, + + /// Could not determine the type of an expression during analysis. + CouldNotDetermineType, + + /// Empty tuple is not allowed in Clarity. + EmptyTuplesNotAllowed, + + /// Invalid or malformed signature in a function definition. + DefineFunctionBadSignature, + + /// Name (e.g., variable, function) is already in use within the same scope. + /// The `String` wraps the conflicting name. + NameAlreadyUsed(String), + + /// Invalid binding syntax in a generic construct (e.g., `let`, `match`). + /// The `SyntaxBindingError` wraps the specific binding error. + BadSyntaxBinding(SyntaxBindingError), + + // Argument counts + /// Function requires at least the specified number of arguments, but fewer were provided. + /// The first `usize` represents the minimum required, and the second represents the actual count. + RequiresAtLeastArguments(usize, usize), + /// Function requires at most the specified number of arguments, but more were provided. + /// The first `usize` represents the maximum allowed, and the second represents the actual count. + RequiresAtMostArguments(usize, usize), + /// 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), + + /// Expected a trait identifier (e.g., `.trait-name`) but found an invalid token. + ExpectedTraitIdentifier, + /// Invalid or malformed signature in a `(define-trait ...)` expression. + DefineTraitBadSignature, + /// Trait definition contains duplicate method names. + /// The `String` wraps the duplicate method name. + DefineTraitDuplicateMethod(String), +} + +/// An error detected during the static analysis of a smart contract at deployment time. +/// +/// These checks are performed once, before any contract execution occurs, to find issues +/// like type mismatches, invalid function signatures, or incorrect control flow. +#[derive(Debug, PartialEq)] +pub enum StaticCheckErrorKind { + // Cost checker errors + /// Arithmetic overflow in cost computation during type-checking, exceeding the maximum threshold. + CostOverflow, + /// Cumulative type-checking cost exceeds the allocated budget, indicating budget depletion. + /// The first `ExecutionCost` represents the total consumed cost, and the second represents the budget limit. + CostBalanceExceeded(ExecutionCost, ExecutionCost), + /// Memory usage during type-checking exceeds the allocated budget. + /// The first `u64` represents the total consumed memory, and the second represents the memory limit. + MemoryBalanceExceeded(u64, u64), + /// Failure in cost-tracking due to an unexpected condition or invalid state. + /// The `String` wraps the specific reason for the failure. + CostComputationFailed(String), + // Time checker errors + /// Type-checking time exceeds the allowed budget, halting analysis to ensure responsiveness. + ExecutionTimeExpired, + + /// Value exceeds the maximum allowed size for type-checking or serialization. + ValueTooLarge, + /// Value is outside the acceptable range for its type (e.g., integer bounds). + ValueOutOfBounds, + /// Type signature nesting depth exceeds the allowed limit during analysis. + TypeSignatureTooDeep, + /// Expected a name (e.g., variable, function) but found an invalid or missing token. + ExpectedName, + /// Supertype (e.g., trait or union) exceeds the maximum allowed size or complexity. + /// This error indicates a transaction would invalidate a block if included. + SupertypeTooLarge, + + // Unexpected interpreter behavior + /// Unexpected condition or failure in the type-checker, indicating a bug or invalid state. + /// This error indicates a transaction would invalidate a block if included. + Expects(String), + + // Match expression errors + /// Invalid syntax in an `option` match expression. + /// The `Box` wraps the underlying error causing the syntax issue. + BadMatchOptionSyntax(Box), + /// Invalid syntax in a `response` match expression. + /// The `Box` wraps the underlying error causing the syntax issue. + BadMatchResponseSyntax(Box), + /// Input to a `match` expression does not conform to the expected type (e.g., `Option` or `Response`). + /// The `Box` wraps the actual type of the provided input. + BadMatchInput(Box), + + /// Constructed list exceeds the maximum allowed length during type-checking. + ConstructedListTooLarge, + + // Type mismatch errors + /// Expected type does not match the actual type during analysis. + /// The first `Box` wraps the expected type, and the second wraps the actual type. + TypeError(Box, Box), + + /// Type description is invalid or malformed, preventing proper type-checking. + InvalidTypeDescription, + /// Referenced type name does not exist or is undefined. + /// The `String` wraps the non-existent type name. + UnknownTypeName(String), + + // Union type mismatch + /// Type does not belong to the expected union of types during analysis. + /// The `Vec` represents the expected types, and the `Box` wraps the actual type. + UnionTypeError(Vec, Box), + /// Expected an optional type but found a different type. + /// The `Box` wraps the actual type provided. + ExpectedOptionalType(Box), + /// Expected a response type but found a different type. + /// The `Box` wraps the actual type provided. + ExpectedResponseType(Box), + /// Expected an optional or response type but found a different type. + /// The `Box` wraps the actual type provided. + ExpectedOptionalOrResponseType(Box), + /// Could not determine the type of the `ok` branch in a response type. + CouldNotDetermineResponseOkType, + /// Could not determine the type of the `err` branch in a response type. + CouldNotDetermineResponseErrType, + /// Could not determine the serialization type for a value during analysis. + CouldNotDetermineSerializationType, + /// Intermediary response types were not properly checked, risking type safety. + UncheckedIntermediaryResponses, + + // Match type errors + /// Could not determine the types for a match expression’s branches. + CouldNotDetermineMatchTypes, + /// Could not determine the type of an expression during analysis. + CouldNotDetermineType, + + // Checker runtime failures + /// Attempt to re-annotate a type that was already annotated, indicating a bug. + TypeAlreadyAnnotatedFailure, + /// Unexpected failure in the type-checker implementation, indicating a bug. + CheckerImplementationFailure, + + // Assets + /// Expected a token name as an argument but found an invalid token. + BadTokenName, + /// Invalid or malformed signature in a `(define-non-fungible-token ...)` expression. + DefineNFTBadSignature, + /// Referenced non-fungible token (NFT) does not exist. + /// The `String` wraps the non-existent token name. + NoSuchNFT(String), + /// Referenced fungible token (FT) does not exist. + /// The `String` wraps the non-existent token name. + NoSuchFT(String), + + // Tuples + /// Tuple field name is invalid or violates naming rules. + BadTupleFieldName, + /// Expected a tuple type but found a different type. + /// The `Box` wraps the actual type provided. + ExpectedTuple(Box), + /// Referenced tuple field does not exist in the tuple type. + /// The `String` wraps the requested field name, and the `TupleTypeSignature` wraps the tuple’s type. + NoSuchTupleField(String, TupleTypeSignature), + /// Empty tuple is not allowed in Clarity. + EmptyTuplesNotAllowed, + /// Invalid tuple construction due to malformed syntax or type mismatch. + /// The `String` wraps the specific error description. + BadTupleConstruction(String), + + // Variables + /// Referenced data variable does not exist in scope. + /// The `String` wraps the non-existent variable name. + NoSuchDataVariable(String), + + // Data map + /// Map name is invalid or violates naming rules. + BadMapName, + /// Referenced data map does not exist in scope. + /// The `String` wraps the non-existent map name. + NoSuchMap(String), + + // Defines + /// Invalid or malformed signature in a function definition. + DefineFunctionBadSignature, + /// Function name is invalid or violates naming rules. + BadFunctionName, + /// Invalid or malformed map type definition in a `(define-map ...)` expression. + BadMapTypeDefinition, + /// Public function must return a response type, but found a different type. + /// The `Box` wraps the actual return type. + PublicFunctionMustReturnResponse(Box), + /// Invalid or malformed variable definition in a `(define-data-var ...)` expression. + DefineVariableBadSignature, + /// Return types of function branches do not match the expected type. + /// The first `Box` wraps the expected type, and the second wraps the actual type. + ReturnTypesMustMatch(Box, Box), + + // Contract-call errors + /// Referenced contract does not exist. + /// The `String` wraps the non-existent contract name. + NoSuchContract(String), + /// Referenced public function does not exist in the specified contract. + /// The first `String` wraps the contract name, and the second wraps the function name. + NoSuchPublicFunction(String, String), + /// Attempt to define a contract with a name that already exists. + /// The `String` wraps the conflicting contract name. + ContractAlreadyExists(String), + /// Expected a contract name in a `contract-call?` expression but found an invalid token. + ContractCallExpectName, + /// Expected a callable type (e.g., function or trait) but found a different type. + /// The `Box` wraps the actual type provided. + ExpectedCallableType(Box), + + // get-block-info? errors + /// Referenced block info property does not exist. + /// The `String` wraps the non-existent property name. + NoSuchBlockInfoProperty(String), + /// Referenced Stacks block info property does not exist. + /// The `String` wraps the non-existent property name. + NoSuchStacksBlockInfoProperty(String), + /// Referenced tenure info property does not exist. + /// The `String` wraps the non-existent property name. + NoSuchTenureInfoProperty(String), + /// Expected a block info property name but found an invalid token. + GetBlockInfoExpectPropertyName, + /// Expected a burn block info property name but found an invalid token. + GetBurnBlockInfoExpectPropertyName, + /// Expected a Stacks block info property name but found an invalid token. + GetStacksBlockInfoExpectPropertyName, + /// Expected a tenure info property name but found an invalid token. + GetTenureInfoExpectPropertyName, + + /// Name (e.g., variable, function) is already in use within the same scope. + /// The `String` wraps the conflicting name. + NameAlreadyUsed(String), + /// Name is a reserved word in Clarity and cannot be used. + /// The `String` wraps the reserved name. + ReservedWord(String), + + // Expect a function, or applying a function to a list + /// Attempt to apply a non-function value as a function. + NonFunctionApplication, + /// Expected a list application but found a different expression. + ExpectedListApplication, + /// Expected a sequence type (e.g., list, buffer) but found a different type. + /// The `Box` wraps the actual type provided. + ExpectedSequence(Box), + /// Sequence length exceeds the maximum allowed limit. + MaxLengthOverflow, + + // Let syntax + /// Invalid syntax in a `let` expression, violating binding or structure rules. + BadLetSyntax, + + // Generic binding syntax + /// Invalid binding syntax in a generic construct (e.g., `let`, `match`). + /// The `SyntaxBindingError` wraps the specific binding error. + BadSyntaxBinding(SyntaxBindingError), + + /// Maximum context depth for type-checking has been reached. + MaxContextDepthReached, + /// Referenced variable is not defined in the current scope. + /// The `String` wraps the non-existent variable name. + UndefinedVariable(String), + + // Argument counts + /// Function requires at least the specified number of arguments, but fewer were provided. + /// The first `usize` represents the minimum required, and the second represents the actual count. + RequiresAtLeastArguments(usize, usize), + /// Function requires at most the specified number of arguments, but more were provided. + /// The first `usize` represents the maximum allowed, and the second represents the actual count. + RequiresAtMostArguments(usize, usize), + /// 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), + /// `if` expression arms have mismatched return types. + /// The first `Box` wraps the type of one arm, and the second wraps the other. + IfArmsMustMatch(Box, Box), + /// `match` expression arms have mismatched return types. + /// The first `Box` wraps the type of one arm, and the second wraps the other. + MatchArmsMustMatch(Box, Box), + /// `default-to` expression types are mismatched. + /// The first `Box` wraps the expected type, and the second wraps the actual type. + DefaultTypesMustMatch(Box, Box), + /// Application of an illegal or unknown function. + /// The `String` wraps the function name. + IllegalOrUnknownFunctionApplication(String), + /// Referenced function is unknown or not defined. + /// The `String` wraps the non-existent function name. + UnknownFunction(String), + + // Traits + /// Referenced trait does not exist in the specified contract. + /// The first `String` wraps the contract name, and the second wraps the trait name. + NoSuchTrait(String, String), + /// Referenced trait is not defined or cannot be found. + /// The `String` wraps the non-existent trait name. + 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. + TraitMethodUnknown(String, String), + /// Expected a trait identifier (e.g., `.trait-name`) but found an invalid token. + ExpectedTraitIdentifier, + /// Invalid implementation of a trait method. + /// The first `String` wraps the trait name, and the second wraps the method name. + BadTraitImplementation(String, String), + /// Invalid or malformed signature in a `(define-trait ...)` expression. + DefineTraitBadSignature, + /// Trait definition contains duplicate method names. + /// The `String` wraps the duplicate method name. + DefineTraitDuplicateMethod(String), + /// Unexpected use of a trait or field reference in a non-trait context. + UnexpectedTraitOrFieldReference, + /// `contract-of` expects a trait type but found a different type. + ContractOfExpectsTrait, + /// Trait implementation is incompatible with the expected trait definition. + /// The first `Box` wraps the expected trait, and the second wraps the actual trait. + IncompatibleTrait(Box, Box), + + /// Attempt to write to contract state in a read-only function. + WriteAttemptedInReadOnly, + /// `at-block` closure must be read-only but contains write operations. + AtBlockClosureMustBeReadOnly, +} + +/// An error that occurs during the runtime analysis of a smart contract at runtime. Could be returnd by: +/// - a contract initialization execution +/// - a contract call execution +/// +/// These errors are found when a contract is executed. They represent dynamic conditions +/// that cannot be determined by static analysis, such as: +/// - Failures based on runtime arguments or state changes. +/// - Value-level type mismatches. #[derive(Debug, PartialEq)] pub enum CheckErrorKind { // Cost checker errors @@ -195,8 +597,6 @@ pub enum CheckErrorKind { // List typing errors /// List elements have mismatched types, violating type consistency. ListTypesMustMatch, - /// Constructed list exceeds the maximum allowed length during type-checking. - ConstructedListTooLarge, // Type mismatch errors /// Expected type does not match the actual type during analysis. @@ -220,15 +620,6 @@ pub enum CheckErrorKind { /// The `Vec` represents the expected types, and the `Box` wraps the invalid value. UnionTypeValueError(Vec, Box), - /// Expected an optional type but found a different type. - /// The `Box` wraps the actual type provided. - ExpectedOptionalType(Box), - /// Expected a response type but found a different type. - /// The `Box` wraps the actual type provided. - ExpectedResponseType(Box), - /// Expected an optional or response type but found a different type. - /// The `Box` wraps the actual type provided. - ExpectedOptionalOrResponseType(Box), /// Expected an optional value but found a different value. /// The `Box` wraps the actual value provided. ExpectedOptionalValue(Box), @@ -238,35 +629,19 @@ pub enum CheckErrorKind { /// Expected an optional or response value but found a different value. /// The `Box` wraps the actual value provided. ExpectedOptionalOrResponseValue(Box), - /// Could not determine the type of the `ok` branch in a response type. - CouldNotDetermineResponseOkType, - /// Could not determine the type of the `err` branch in a response type. - CouldNotDetermineResponseErrType, /// Could not determine the serialization type for a value during analysis. CouldNotDetermineSerializationType, - /// Intermediary response types were not properly checked, risking type safety. - UncheckedIntermediaryResponses, /// Expected a contract principal value but found a different value. /// The `Box` wraps the actual value provided. ExpectedContractPrincipalValue(Box), // Match type errors - /// Could not determine the types for a match expression’s branches. - CouldNotDetermineMatchTypes, /// Could not determine the type of an expression during analysis. CouldNotDetermineType, - // Checker runtime failures - /// Attempt to re-annotate a type that was already annotated, indicating a bug. - TypeAlreadyAnnotatedFailure, - /// Unexpected failure in the type-checker implementation, indicating a bug. - CheckerImplementationFailure, - // Assets /// Expected a token name as an argument but found an invalid token. BadTokenName, - /// Invalid or malformed signature in a `(define-non-fungible-token ...)` expression. - DefineNFTBadSignature, /// Referenced non-fungible token (NFT) does not exist. /// The `String` wraps the non-existent token name. NoSuchNFT(String), @@ -287,8 +662,6 @@ pub enum CheckErrorKind { BadBurnFTArguments, // Tuples - /// Tuple field name is invalid or violates naming rules. - BadTupleFieldName, /// Expected a tuple type but found a different type. /// The `Box` wraps the actual type provided. ExpectedTuple(Box), @@ -297,9 +670,6 @@ pub enum CheckErrorKind { NoSuchTupleField(String, TupleTypeSignature), /// Empty tuple is not allowed in Clarity. EmptyTuplesNotAllowed, - /// Invalid tuple construction due to malformed syntax or type mismatch. - /// The `String` wraps the specific error description. - BadTupleConstruction(String), // Variables /// Referenced data variable does not exist in scope. @@ -307,8 +677,6 @@ pub enum CheckErrorKind { NoSuchDataVariable(String), // Data map - /// Map name is invalid or violates naming rules. - BadMapName, /// Referenced data map does not exist in scope. /// The `String` wraps the non-existent map name. NoSuchMap(String), @@ -318,13 +686,9 @@ pub enum CheckErrorKind { DefineFunctionBadSignature, /// Function name is invalid or violates naming rules. BadFunctionName, - /// Invalid or malformed map type definition in a `(define-map ...)` expression. - BadMapTypeDefinition, /// Public function must return a response type, but found a different type. /// The `Box` wraps the actual return type. PublicFunctionMustReturnResponse(Box), - /// Invalid or malformed variable definition in a `(define-data-var ...)` expression. - DefineVariableBadSignature, /// Return types of function branches do not match the expected type. /// The first `Box` wraps the expected type, and the second wraps the actual type. ReturnTypesMustMatch(Box, Box), @@ -348,27 +712,16 @@ pub enum CheckErrorKind { ContractAlreadyExists(String), /// Expected a contract name in a `contract-call?` expression but found an invalid token. ContractCallExpectName, - /// Expected a callable type (e.g., function or trait) but found a different type. - /// The `Box` wraps the actual type provided. - ExpectedCallableType(Box), // get-block-info? errors - /// Referenced block info property does not exist. - /// The `String` wraps the non-existent property name. - NoSuchBlockInfoProperty(String), /// Referenced burn block info property does not exist. /// The `String` wraps the non-existent property name. NoSuchBurnBlockInfoProperty(String), /// Referenced Stacks block info property does not exist. /// The `String` wraps the non-existent property name. NoSuchStacksBlockInfoProperty(String), - /// Referenced tenure info property does not exist. - /// The `String` wraps the non-existent property name. - NoSuchTenureInfoProperty(String), /// Expected a block info property name but found an invalid token. GetBlockInfoExpectPropertyName, - /// Expected a burn block info property name but found an invalid token. - GetBurnBlockInfoExpectPropertyName, /// Expected a Stacks block info property name but found an invalid token. GetStacksBlockInfoExpectPropertyName, /// Expected a tenure info property name but found an invalid token. @@ -377,9 +730,6 @@ pub enum CheckErrorKind { /// Name (e.g., variable, function) is already in use within the same scope. /// The `String` wraps the conflicting name. NameAlreadyUsed(String), - /// Name is a reserved word in Clarity and cannot be used. - /// The `String` wraps the reserved name. - ReservedWord(String), // Expect a function, or applying a function to a list /// Attempt to apply a non-function value as a function. @@ -389,8 +739,6 @@ pub enum CheckErrorKind { /// Expected a sequence type (e.g., list, buffer) but found a different type. /// The `Box` wraps the actual type provided. ExpectedSequence(Box), - /// Sequence length exceeds the maximum allowed limit. - MaxLengthOverflow, // Let syntax /// Invalid syntax in a `let` expression, violating binding or structure rules. @@ -401,8 +749,6 @@ pub enum CheckErrorKind { /// The `SyntaxBindingError` wraps the specific binding error. BadSyntaxBinding(SyntaxBindingError), - /// Maximum context depth for type-checking has been reached. - MaxContextDepthReached, /// Referenced function is not defined in the current scope. /// The `String` wraps the non-existent function name. UndefinedFunction(String), @@ -420,26 +766,8 @@ pub enum CheckErrorKind { /// 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), - /// `if` expression arms have mismatched return types. - /// The first `Box` wraps the type of one arm, and the second wraps the other. - IfArmsMustMatch(Box, Box), - /// `match` expression arms have mismatched return types. - /// The first `Box` wraps the type of one arm, and the second wraps the other. - MatchArmsMustMatch(Box, Box), - /// `default-to` expression types are mismatched. - /// The first `Box` wraps the expected type, and the second wraps the actual type. - DefaultTypesMustMatch(Box, Box), - /// Application of an illegal or unknown function. - /// The `String` wraps the function name. - IllegalOrUnknownFunctionApplication(String), - /// Referenced function is unknown or not defined. - /// The `String` wraps the non-existent function name. - UnknownFunction(String), // Traits - /// Referenced trait does not exist in the specified contract. - /// The first `String` wraps the contract name, and the second wraps the trait name. - NoSuchTrait(String, String), /// Referenced trait is not defined or cannot be found. /// The `String` wraps the non-existent trait name. TraitReferenceUnknown(String), @@ -448,8 +776,6 @@ pub enum CheckErrorKind { TraitMethodUnknown(String, String), /// Expected a trait identifier (e.g., `.trait-name`) but found an invalid token. ExpectedTraitIdentifier, - /// Trait reference is not allowed in the current context (e.g., storage). - TraitReferenceNotAllowed, /// Invalid implementation of a trait method. /// The first `String` wraps the trait name, and the second wraps the method name. BadTraitImplementation(String, String), @@ -458,15 +784,11 @@ pub enum CheckErrorKind { /// Trait definition contains duplicate method names. /// The `String` wraps the duplicate method name. DefineTraitDuplicateMethod(String), - /// Unexpected use of a trait or field reference in a non-trait context. - UnexpectedTraitOrFieldReference, + /// Trait-based contract call used in a read-only context, which is prohibited. TraitBasedContractCallInReadOnly, /// `contract-of` expects a trait type but found a different type. ContractOfExpectsTrait, - /// Trait implementation is incompatible with the expected trait definition. - /// The first `Box` wraps the expected trait, and the second wraps the actual trait. - IncompatibleTrait(Box, Box), // Strings /// String contains invalid or disallowed characters (e.g., non-ASCII in ASCII strings). @@ -480,17 +802,18 @@ pub enum CheckErrorKind { /// Attempt to write to contract state in a read-only function. WriteAttemptedInReadOnly, - /// `at-block` closure must be read-only but contains write operations. - AtBlockClosureMustBeReadOnly, } #[derive(Debug, PartialEq)] -/// Represents an error encountered during Clarity's type-checking and semantic analysis phase. -/// Wraps a `CheckErrorKind` variant, optionally includes the expressions causing the error, -/// and provides diagnostic information for debugging. +/// A complete static analysis error, combining the error with diagnostic information. +/// +/// This struct wraps a [`StaticCheckErrorKind`] variant with its source location +/// (like line and column numbers) and the code expression that caused the error. +/// It provides the full context needed to report a clear, actionable error to a +/// developer during contract deployment. pub struct StaticCheckError { /// The specific type-checking or semantic error that occurred. - pub err: Box, + pub err: Box, /// Optional vector of expressions related to the error, if available. pub expressions: Option>, /// Diagnostic details (e.g., line/column numbers, error message, suggestions) around the error. @@ -508,8 +831,17 @@ impl CheckErrorKind { } } +impl StaticCheckErrorKind { + pub fn rejectable(&self) -> bool { + matches!( + self, + StaticCheckErrorKind::SupertypeTooLarge | StaticCheckErrorKind::Expects(_) + ) + } +} + impl StaticCheckError { - pub fn new(err: CheckErrorKind) -> StaticCheckError { + pub fn new(err: StaticCheckErrorKind) -> StaticCheckError { let diagnostic = Diagnostic::err(&err); StaticCheckError { err: Box::new(err), @@ -532,7 +864,7 @@ impl StaticCheckError { self.expressions.replace(exprs.to_vec()); } - pub fn with_expression(err: CheckErrorKind, expr: &SymbolicExpression) -> Self { + pub fn with_expression(err: StaticCheckErrorKind, expr: &SymbolicExpression) -> Self { let mut r = Self::new(err); r.set_expression(expr); r @@ -541,30 +873,42 @@ impl StaticCheckError { impl From<(SyntaxBindingError, &SymbolicExpression)> for StaticCheckError { fn from(e: (SyntaxBindingError, &SymbolicExpression)) -> Self { - Self::with_expression(CheckErrorKind::BadSyntaxBinding(e.0), e.1) + Self::with_expression(StaticCheckErrorKind::BadSyntaxBinding(e.0), e.1) } } -impl From<(CheckErrorKind, &SymbolicExpression)> for StaticCheckError { - fn from(e: (CheckErrorKind, &SymbolicExpression)) -> Self { - let mut ce = Self::new(e.0); +impl From<(CommonCheckErrorKind, &SymbolicExpression)> for StaticCheckError { + fn from(e: (CommonCheckErrorKind, &SymbolicExpression)) -> Self { + let mut ce = Self::new(e.0.into()); ce.set_expression(e.1); ce } } -impl From<(CheckErrorKind, &SymbolicExpression)> for CheckErrorKind { - fn from(e: (CheckErrorKind, &SymbolicExpression)) -> Self { +impl From<(CommonCheckErrorKind, &SymbolicExpression)> for CommonCheckErrorKind { + fn from(e: (CommonCheckErrorKind, &SymbolicExpression)) -> Self { e.0 } } +impl From<(CommonCheckErrorKind, &SymbolicExpression)> for CheckErrorKind { + fn from(e: (CommonCheckErrorKind, &SymbolicExpression)) -> Self { + e.0.into() + } +} + impl fmt::Display for CheckErrorKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{self:?}") } } +impl fmt::Display for StaticCheckErrorKind { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{self:?}") + } +} + impl fmt::Display for StaticCheckError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.err)?; @@ -579,7 +923,30 @@ impl fmt::Display for StaticCheckError { impl From for StaticCheckError { fn from(err: CostErrors) -> Self { - StaticCheckError::from(CheckErrorKind::from(err)) + StaticCheckError::from(StaticCheckErrorKind::from(err)) + } +} + +impl From for StaticCheckErrorKind { + fn from(err: CostErrors) -> Self { + match err { + CostErrors::CostOverflow => StaticCheckErrorKind::CostOverflow, + CostErrors::CostBalanceExceeded(a, b) => { + StaticCheckErrorKind::CostBalanceExceeded(a, b) + } + CostErrors::MemoryBalanceExceeded(a, b) => { + StaticCheckErrorKind::MemoryBalanceExceeded(a, b) + } + CostErrors::CostComputationFailed(s) => StaticCheckErrorKind::CostComputationFailed(s), + CostErrors::CostContractLoadFailure => { + StaticCheckErrorKind::CostComputationFailed("Failed to load cost contract".into()) + } + CostErrors::InterpreterFailure => StaticCheckErrorKind::Expects( + "Unexpected interpreter failure in cost computation".into(), + ), + CostErrors::Expect(s) => StaticCheckErrorKind::Expects(s), + CostErrors::ExecutionTimeExpired => StaticCheckErrorKind::ExecutionTimeExpired, + } } } @@ -602,6 +969,29 @@ impl From for CheckErrorKind { } } +impl From for CommonCheckErrorKind { + fn from(err: CostErrors) -> Self { + match err { + CostErrors::CostOverflow => CommonCheckErrorKind::CostOverflow, + CostErrors::CostBalanceExceeded(a, b) => { + CommonCheckErrorKind::CostBalanceExceeded(a, b) + } + CostErrors::MemoryBalanceExceeded(a, b) => { + CommonCheckErrorKind::MemoryBalanceExceeded(a, b) + } + CostErrors::CostComputationFailed(s) => CommonCheckErrorKind::CostComputationFailed(s), + CostErrors::CostContractLoadFailure => { + CommonCheckErrorKind::CostComputationFailed("Failed to load cost contract".into()) + } + CostErrors::InterpreterFailure => CommonCheckErrorKind::Expects( + "Unexpected interpreter failure in cost computation".into(), + ), + CostErrors::Expect(s) => CommonCheckErrorKind::Expects(s), + CostErrors::ExecutionTimeExpired => CommonCheckErrorKind::ExecutionTimeExpired, + } + } +} + impl error::Error for StaticCheckError { fn source(&self) -> Option<&(dyn error::Error + 'static)> { None @@ -614,30 +1004,166 @@ impl error::Error for CheckErrorKind { } } -impl From for StaticCheckError { - fn from(err: CheckErrorKind) -> Self { +impl From for StaticCheckError { + fn from(err: StaticCheckErrorKind) -> Self { StaticCheckError::new(err) } } +impl From for StaticCheckError { + fn from(err: CommonCheckErrorKind) -> Self { + StaticCheckError::new(StaticCheckErrorKind::from(err)) + } +} + +impl From for CheckErrorKind { + fn from(err: CommonCheckErrorKind) -> Self { + match err { + CommonCheckErrorKind::CostOverflow => CheckErrorKind::CostOverflow, + CommonCheckErrorKind::CostBalanceExceeded(a, b) => { + CheckErrorKind::CostBalanceExceeded(a, b) + } + CommonCheckErrorKind::MemoryBalanceExceeded(a, b) => { + CheckErrorKind::MemoryBalanceExceeded(a, b) + } + CommonCheckErrorKind::CostComputationFailed(s) => { + CheckErrorKind::CostComputationFailed(s) + } + CommonCheckErrorKind::ExecutionTimeExpired => CheckErrorKind::ExecutionTimeExpired, + CommonCheckErrorKind::IncorrectArgumentCount(expected, args) => { + CheckErrorKind::IncorrectArgumentCount(expected, args) + } + CommonCheckErrorKind::RequiresAtLeastArguments(expected, args) => { + CheckErrorKind::RequiresAtLeastArguments(expected, args) + } + CommonCheckErrorKind::RequiresAtMostArguments(expected, args) => { + CheckErrorKind::RequiresAtMostArguments(expected, args) + } + CommonCheckErrorKind::ExpectedName => CheckErrorKind::ExpectedName, + CommonCheckErrorKind::DefineFunctionBadSignature => { + CheckErrorKind::DefineFunctionBadSignature + } + CommonCheckErrorKind::ExpectedTraitIdentifier => { + CheckErrorKind::ExpectedTraitIdentifier + } + CommonCheckErrorKind::Expects(s) => CheckErrorKind::Expects(s), + CommonCheckErrorKind::CouldNotDetermineType => CheckErrorKind::CouldNotDetermineType, + CommonCheckErrorKind::ValueTooLarge => CheckErrorKind::ValueTooLarge, + CommonCheckErrorKind::TypeSignatureTooDeep => CheckErrorKind::TypeSignatureTooDeep, + CommonCheckErrorKind::DefineTraitDuplicateMethod(s) => { + CheckErrorKind::DefineTraitDuplicateMethod(s) + } + CommonCheckErrorKind::DefineTraitBadSignature => { + CheckErrorKind::DefineTraitBadSignature + } + CommonCheckErrorKind::InvalidTypeDescription => CheckErrorKind::InvalidTypeDescription, + CommonCheckErrorKind::SupertypeTooLarge => CheckErrorKind::SupertypeTooLarge, + CommonCheckErrorKind::TypeError(a, b) => CheckErrorKind::TypeError(a, b), + CommonCheckErrorKind::BadSyntaxBinding(e) => CheckErrorKind::BadSyntaxBinding(e), + CommonCheckErrorKind::ValueOutOfBounds => CheckErrorKind::ValueOutOfBounds, + CommonCheckErrorKind::CouldNotDetermineSerializationType => { + CheckErrorKind::CouldNotDetermineSerializationType + } + CommonCheckErrorKind::EmptyTuplesNotAllowed => CheckErrorKind::EmptyTuplesNotAllowed, + CommonCheckErrorKind::NameAlreadyUsed(name) => CheckErrorKind::NameAlreadyUsed(name), + CommonCheckErrorKind::UnknownTypeName(name) => CheckErrorKind::UnknownTypeName(name), + } + } +} + +impl From for StaticCheckErrorKind { + fn from(err: CommonCheckErrorKind) -> Self { + match err { + CommonCheckErrorKind::CostOverflow => StaticCheckErrorKind::CostOverflow, + CommonCheckErrorKind::CostBalanceExceeded(a, b) => { + StaticCheckErrorKind::CostBalanceExceeded(a, b) + } + CommonCheckErrorKind::MemoryBalanceExceeded(a, b) => { + StaticCheckErrorKind::MemoryBalanceExceeded(a, b) + } + CommonCheckErrorKind::CostComputationFailed(s) => { + StaticCheckErrorKind::CostComputationFailed(s) + } + CommonCheckErrorKind::ExecutionTimeExpired => { + StaticCheckErrorKind::ExecutionTimeExpired + } + CommonCheckErrorKind::IncorrectArgumentCount(expected, args) => { + StaticCheckErrorKind::IncorrectArgumentCount(expected, args) + } + CommonCheckErrorKind::RequiresAtLeastArguments(expected, args) => { + StaticCheckErrorKind::RequiresAtLeastArguments(expected, args) + } + CommonCheckErrorKind::RequiresAtMostArguments(expected, args) => { + StaticCheckErrorKind::RequiresAtMostArguments(expected, args) + } + CommonCheckErrorKind::ExpectedName => StaticCheckErrorKind::ExpectedName, + CommonCheckErrorKind::DefineFunctionBadSignature => { + StaticCheckErrorKind::DefineFunctionBadSignature + } + CommonCheckErrorKind::ExpectedTraitIdentifier => { + StaticCheckErrorKind::ExpectedTraitIdentifier + } + CommonCheckErrorKind::Expects(s) => StaticCheckErrorKind::Expects(s), + CommonCheckErrorKind::CouldNotDetermineType => { + StaticCheckErrorKind::CouldNotDetermineType + } + CommonCheckErrorKind::ValueTooLarge => StaticCheckErrorKind::ValueTooLarge, + CommonCheckErrorKind::TypeSignatureTooDeep => { + StaticCheckErrorKind::TypeSignatureTooDeep + } + CommonCheckErrorKind::DefineTraitDuplicateMethod(s) => { + StaticCheckErrorKind::DefineTraitDuplicateMethod(s) + } + CommonCheckErrorKind::DefineTraitBadSignature => { + StaticCheckErrorKind::DefineTraitBadSignature + } + CommonCheckErrorKind::InvalidTypeDescription => { + StaticCheckErrorKind::InvalidTypeDescription + } + CommonCheckErrorKind::SupertypeTooLarge => StaticCheckErrorKind::SupertypeTooLarge, + CommonCheckErrorKind::TypeError(a, b) => StaticCheckErrorKind::TypeError(a, b), + CommonCheckErrorKind::BadSyntaxBinding(e) => StaticCheckErrorKind::BadSyntaxBinding(e), + CommonCheckErrorKind::ValueOutOfBounds => StaticCheckErrorKind::ValueOutOfBounds, + CommonCheckErrorKind::CouldNotDetermineSerializationType => { + StaticCheckErrorKind::CouldNotDetermineSerializationType + } + CommonCheckErrorKind::EmptyTuplesNotAllowed => { + StaticCheckErrorKind::EmptyTuplesNotAllowed + } + CommonCheckErrorKind::NameAlreadyUsed(name) => { + StaticCheckErrorKind::NameAlreadyUsed(name) + } + CommonCheckErrorKind::UnknownTypeName(name) => { + StaticCheckErrorKind::UnknownTypeName(name) + } + } + } +} + #[cfg(any(test, feature = "testing"))] -impl From for String { - fn from(o: CheckErrorKind) -> Self { +impl From for String { + fn from(o: StaticCheckErrorKind) -> Self { o.to_string() } } -pub fn check_argument_count(expected: usize, args: &[T]) -> Result<(), CheckErrorKind> { +pub fn check_argument_count(expected: usize, args: &[T]) -> Result<(), CommonCheckErrorKind> { if args.len() != expected { - Err(CheckErrorKind::IncorrectArgumentCount(expected, args.len())) + Err(CommonCheckErrorKind::IncorrectArgumentCount( + expected, + args.len(), + )) } else { Ok(()) } } -pub fn check_arguments_at_least(expected: usize, args: &[T]) -> Result<(), CheckErrorKind> { +pub fn check_arguments_at_least( + expected: usize, + args: &[T], +) -> Result<(), CommonCheckErrorKind> { if args.len() < expected { - Err(CheckErrorKind::RequiresAtLeastArguments( + Err(CommonCheckErrorKind::RequiresAtLeastArguments( expected, args.len(), )) @@ -646,9 +1172,9 @@ pub fn check_arguments_at_least(expected: usize, args: &[T]) -> Result<(), Ch } } -pub fn check_arguments_at_most(expected: usize, args: &[T]) -> Result<(), CheckErrorKind> { +pub fn check_arguments_at_most(expected: usize, args: &[T]) -> Result<(), CommonCheckErrorKind> { if args.len() > expected { - Err(CheckErrorKind::RequiresAtMostArguments( + Err(CommonCheckErrorKind::RequiresAtMostArguments( expected, args.len(), )) @@ -672,125 +1198,329 @@ fn formatted_expected_types(expected_types: &[TypeSignature]) -> String { expected_types_joined } -impl DiagnosableError for CheckErrorKind { +impl DiagnosableError for StaticCheckErrorKind { fn message(&self) -> String { match &self { - CheckErrorKind::SupertypeTooLarge => "supertype of two types is too large".into(), - CheckErrorKind::Expects(s) => format!("unexpected interpreter behavior: {s}"), - CheckErrorKind::BadMatchOptionSyntax(source) => + StaticCheckErrorKind::SupertypeTooLarge => "supertype of two types is too large".into(), + StaticCheckErrorKind::Expects(s) => format!("unexpected interpreter behavior: {s}"), + StaticCheckErrorKind::BadMatchOptionSyntax(source) => format!("match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: {}", source.message()), - CheckErrorKind::BadMatchResponseSyntax(source) => + StaticCheckErrorKind::BadMatchResponseSyntax(source) => format!("match on a result type uses the following syntax: (match input ok-name if-ok-expression err-name if-err-expression). Caused by: {}", source.message()), - CheckErrorKind::BadMatchInput(t) => + StaticCheckErrorKind::BadMatchInput(t) => format!("match requires an input of either a response or optional, found input: '{t}'"), - CheckErrorKind::CostOverflow => "contract execution cost overflowed cost counter".into(), - CheckErrorKind::CostBalanceExceeded(a, b) => format!("contract execution cost exceeded budget: {a:?} > {b:?}"), - CheckErrorKind::MemoryBalanceExceeded(a, b) => format!("contract execution cost exceeded memory budget: {a:?} > {b:?}"), + StaticCheckErrorKind::CostOverflow => "contract execution cost overflowed cost counter".into(), + StaticCheckErrorKind::CostBalanceExceeded(a, b) => format!("contract execution cost exceeded budget: {a:?} > {b:?}"), + StaticCheckErrorKind::MemoryBalanceExceeded(a, b) => format!("contract execution cost exceeded memory budget: {a:?} > {b:?}"), + StaticCheckErrorKind::InvalidTypeDescription => "supplied type description is invalid".into(), + StaticCheckErrorKind::EmptyTuplesNotAllowed => "tuple types may not be empty".into(), + StaticCheckErrorKind::UnknownTypeName(name) => format!("failed to parse type: '{name}'"), + StaticCheckErrorKind::ValueTooLarge => "created a type which was greater than maximum allowed value size".into(), + StaticCheckErrorKind::ValueOutOfBounds => "created a type which value size was out of defined bounds".into(), + StaticCheckErrorKind::TypeSignatureTooDeep => "created a type which was deeper than maximum allowed type depth".into(), + StaticCheckErrorKind::ExpectedName => "expected a name argument to this function".into(), + StaticCheckErrorKind::ConstructedListTooLarge => "reached limit of elements in a sequence".into(), + StaticCheckErrorKind::TypeError(expected_type, found_type) => format!("expecting expression of type '{expected_type}', found '{found_type}'"), + StaticCheckErrorKind::UnionTypeError(expected_types, found_type) => format!("expecting expression of type {}, found '{}'", formatted_expected_types(expected_types), found_type), + StaticCheckErrorKind::ExpectedOptionalType(found_type) => format!("expecting expression of type 'optional', found '{found_type}'"), + StaticCheckErrorKind::ExpectedOptionalOrResponseType(found_type) => format!("expecting expression of type 'optional' or 'response', found '{found_type}'"), + StaticCheckErrorKind::ExpectedResponseType(found_type) => format!("expecting expression of type 'response', found '{found_type}'"), + StaticCheckErrorKind::CouldNotDetermineResponseOkType => "attempted to obtain 'ok' value from response, but 'ok' type is indeterminate".into(), + StaticCheckErrorKind::CouldNotDetermineResponseErrType => "attempted to obtain 'err' value from response, but 'err' type is indeterminate".into(), + StaticCheckErrorKind::CouldNotDetermineMatchTypes => "attempted to match on an (optional) or (response) type where either the some, ok, or err type is indeterminate. you may wish to use unwrap-panic or unwrap-err-panic instead.".into(), + StaticCheckErrorKind::CouldNotDetermineType => "type of expression cannot be determined".into(), + StaticCheckErrorKind::BadTupleFieldName => "invalid tuple field name".into(), + StaticCheckErrorKind::ExpectedTuple(type_signature) => format!("expecting tuple, found '{type_signature}'"), + StaticCheckErrorKind::NoSuchTupleField(field_name, tuple_signature) => format!("cannot find field '{field_name}' in tuple '{tuple_signature}'"), + StaticCheckErrorKind::BadTupleConstruction(message) => format!("invalid tuple syntax: {message}"), + StaticCheckErrorKind::NoSuchDataVariable(var_name) => format!("use of unresolved persisted variable '{var_name}'"), + StaticCheckErrorKind::BadMapName => "invalid map name".into(), + StaticCheckErrorKind::NoSuchMap(map_name) => format!("use of unresolved map '{map_name}'"), + StaticCheckErrorKind::DefineFunctionBadSignature => "invalid function definition".into(), + StaticCheckErrorKind::BadFunctionName => "invalid function name".into(), + StaticCheckErrorKind::BadMapTypeDefinition => "invalid map definition".into(), + StaticCheckErrorKind::PublicFunctionMustReturnResponse(found_type) => format!("public functions must return an expression of type 'response', found '{found_type}'"), + StaticCheckErrorKind::DefineVariableBadSignature => "invalid variable definition".into(), + StaticCheckErrorKind::ReturnTypesMustMatch(type_1, type_2) => format!("detected two execution paths, returning two different expression types (got '{type_1}' and '{type_2}')"), + StaticCheckErrorKind::NoSuchContract(contract_identifier) => format!("use of unresolved contract '{contract_identifier}'"), + StaticCheckErrorKind::NoSuchPublicFunction(contract_identifier, function_name) => format!("contract '{contract_identifier}' has no public function '{function_name}'"), + StaticCheckErrorKind::ContractAlreadyExists(contract_identifier) => format!("contract name '{contract_identifier}' conflicts with existing contract"), + StaticCheckErrorKind::ContractCallExpectName => "missing contract name for call".into(), + StaticCheckErrorKind::ExpectedCallableType(found_type) => format!("expected a callable contract, found {found_type}"), + StaticCheckErrorKind::NoSuchBlockInfoProperty(property_name) => format!("use of block unknown property '{property_name}'"), + StaticCheckErrorKind::NoSuchStacksBlockInfoProperty(property_name) => format!("use of unknown stacks block property '{property_name}'"), + StaticCheckErrorKind::NoSuchTenureInfoProperty(property_name) => format!("use of unknown tenure property '{property_name}'"), + StaticCheckErrorKind::GetBlockInfoExpectPropertyName => "missing property name for block info introspection".into(), + StaticCheckErrorKind::GetBurnBlockInfoExpectPropertyName => "missing property name for burn block info introspection".into(), + StaticCheckErrorKind::GetStacksBlockInfoExpectPropertyName => "missing property name for stacks block info introspection".into(), + StaticCheckErrorKind::GetTenureInfoExpectPropertyName => "missing property name for tenure info introspection".into(), + StaticCheckErrorKind::NameAlreadyUsed(name) => format!("defining '{name}' conflicts with previous value"), + StaticCheckErrorKind::ReservedWord(name) => format!("{name} is a reserved word"), + StaticCheckErrorKind::NonFunctionApplication => "expecting expression of type function".into(), + StaticCheckErrorKind::ExpectedListApplication => "expecting expression of type list".into(), + StaticCheckErrorKind::ExpectedSequence(found_type) => format!("expecting expression of type 'list', 'buff', 'string-ascii' or 'string-utf8' - found '{found_type}'"), + StaticCheckErrorKind::MaxLengthOverflow => format!("expecting a value <= {}", u32::MAX), + StaticCheckErrorKind::BadLetSyntax => "invalid syntax of 'let'".into(), + StaticCheckErrorKind::BadSyntaxBinding(binding_error) => format!("invalid syntax binding: {}", &binding_error.message()), + StaticCheckErrorKind::MaxContextDepthReached => "reached depth limit".into(), + StaticCheckErrorKind::UndefinedVariable(var_name) => format!("use of unresolved variable '{var_name}'"), + StaticCheckErrorKind::RequiresAtLeastArguments(expected, found) => format!("expecting >= {expected} arguments, got {found}"), + StaticCheckErrorKind::RequiresAtMostArguments(expected, found) => format!("expecting < {expected} arguments, got {found}"), + StaticCheckErrorKind::IncorrectArgumentCount(expected_count, found_count) => format!("expecting {expected_count} arguments, got {found_count}"), + StaticCheckErrorKind::IfArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'if' must match (got '{type_1}' and '{type_2}')"), + StaticCheckErrorKind::MatchArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'match' must match (got '{type_1}' and '{type_2}')"), + StaticCheckErrorKind::DefaultTypesMustMatch(type_1, type_2) => format!("expression types passed in 'default-to' must match (got '{type_1}' and '{type_2}')"), + StaticCheckErrorKind::IllegalOrUnknownFunctionApplication(function_name) => format!("use of illegal / unresolved function '{function_name}"), + StaticCheckErrorKind::UnknownFunction(function_name) => format!("use of unresolved function '{function_name}'"), + 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::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}')"), + StaticCheckErrorKind::NoSuchFT(asset_name) => format!("tried to use token function with a undefined token ('{asset_name}')"), + StaticCheckErrorKind::NoSuchTrait(contract_name, trait_name) => format!("use of unresolved trait {contract_name}.{trait_name}"), + StaticCheckErrorKind::TraitReferenceUnknown(trait_name) => format!("use of undeclared trait <{trait_name}>"), + StaticCheckErrorKind::TraitMethodUnknown(trait_name, func_name) => format!("method '{func_name}' unspecified in trait <{trait_name}>"), + StaticCheckErrorKind::BadTraitImplementation(trait_name, func_name) => format!("invalid signature for method '{func_name}' regarding trait's specification <{trait_name}>"), + StaticCheckErrorKind::ExpectedTraitIdentifier => "expecting expression of type trait identifier".into(), + StaticCheckErrorKind::UnexpectedTraitOrFieldReference => "unexpected use of trait reference or field".into(), + StaticCheckErrorKind::DefineTraitBadSignature => "invalid trait definition".into(), + StaticCheckErrorKind::DefineTraitDuplicateMethod(method_name) => format!("duplicate method name '{method_name}' in trait definition"), + StaticCheckErrorKind::ContractOfExpectsTrait => "trait reference expected".into(), + StaticCheckErrorKind::IncompatibleTrait(expected_trait, actual_trait) => format!("trait '{actual_trait}' is not a compatible with expected trait, '{expected_trait}'"), + StaticCheckErrorKind::TypeAlreadyAnnotatedFailure | StaticCheckErrorKind::CheckerImplementationFailure => { + "internal error - please file an issue on https://github.com/stacks-network/stacks-blockchain".into() + }, + StaticCheckErrorKind::UncheckedIntermediaryResponses => "intermediary responses in consecutive statements must be checked".into(), + StaticCheckErrorKind::CostComputationFailed(s) => format!("contract cost computation failed: {s}"), + StaticCheckErrorKind::CouldNotDetermineSerializationType => "could not determine the input type for the serialization function".into(), + StaticCheckErrorKind::ExecutionTimeExpired => "execution time expired".into(), + } + } + + fn suggestion(&self) -> Option { + match &self { + StaticCheckErrorKind::BadLetSyntax => Some( + "'let' syntax example: (let ((supply 1000) (ttl 60)) )".into(), + ), + StaticCheckErrorKind::TraitReferenceUnknown(_) => Some( + "traits should be either defined, with define-trait, or imported, with use-trait." + .into(), + ), + StaticCheckErrorKind::NoSuchBlockInfoProperty(_) => Some( + "properties available: time, header-hash, burnchain-header-hash, vrf-seed".into(), + ), + _ => None, + } + } +} + +impl DiagnosableError for CheckErrorKind { + fn message(&self) -> String { + match &self { + CheckErrorKind::SupertypeTooLarge => "supertype of two types is too large".into(), + CheckErrorKind::Expects(s) => format!("unexpected interpreter behavior: {s}"), + CheckErrorKind::BadMatchOptionSyntax(source) => format!( + "match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: {}", + source.message() + ), + CheckErrorKind::BadMatchResponseSyntax(source) => format!( + "match on a result type uses the following syntax: (match input ok-name if-ok-expression err-name if-err-expression). Caused by: {}", + source.message() + ), + CheckErrorKind::BadMatchInput(t) => format!( + "match requires an input of either a response or optional, found input: '{t}'" + ), + CheckErrorKind::CostOverflow => { + "contract execution cost overflowed cost counter".into() + } + CheckErrorKind::CostBalanceExceeded(a, b) => { + format!("contract execution cost exceeded budget: {a:?} > {b:?}") + } + CheckErrorKind::MemoryBalanceExceeded(a, b) => { + format!("contract execution cost exceeded memory budget: {a:?} > {b:?}") + } CheckErrorKind::InvalidTypeDescription => "supplied type description is invalid".into(), CheckErrorKind::EmptyTuplesNotAllowed => "tuple types may not be empty".into(), CheckErrorKind::UnknownTypeName(name) => format!("failed to parse type: '{name}'"), - CheckErrorKind::ValueTooLarge => "created a type which was greater than maximum allowed value size".into(), - CheckErrorKind::ValueOutOfBounds => "created a type which value size was out of defined bounds".into(), - CheckErrorKind::TypeSignatureTooDeep => "created a type which was deeper than maximum allowed type depth".into(), + CheckErrorKind::ValueTooLarge => { + "created a type which was greater than maximum allowed value size".into() + } + CheckErrorKind::ValueOutOfBounds => { + "created a type which value size was out of defined bounds".into() + } + CheckErrorKind::TypeSignatureTooDeep => { + "created a type which was deeper than maximum allowed type depth".into() + } CheckErrorKind::ExpectedName => "expected a name argument to this function".into(), - CheckErrorKind::ListTypesMustMatch => "expecting elements of same type in a list".into(), - CheckErrorKind::ConstructedListTooLarge => "reached limit of elements in a sequence".into(), - CheckErrorKind::TypeError(expected_type, found_type) => format!("expecting expression of type '{expected_type}', found '{found_type}'"), - CheckErrorKind::TypeValueError(expected_type, found_value) => format!("expecting expression of type '{expected_type}', found '{found_value}'"), - CheckErrorKind::UnionTypeError(expected_types, found_type) => format!("expecting expression of type {}, found '{}'", formatted_expected_types(expected_types), found_type), - CheckErrorKind::UnionTypeValueError(expected_types, found_type) => format!("expecting expression of type {}, found '{}'", formatted_expected_types(expected_types), found_type), - CheckErrorKind::ExpectedOptionalType(found_type) => format!("expecting expression of type 'optional', found '{found_type}'"), - CheckErrorKind::ExpectedOptionalOrResponseType(found_type) => format!("expecting expression of type 'optional' or 'response', found '{found_type}'"), - CheckErrorKind::ExpectedOptionalOrResponseValue(found_value) => format!("expecting expression of type 'optional' or 'response', found '{found_value}'"), - CheckErrorKind::ExpectedResponseType(found_type) => format!("expecting expression of type 'response', found '{found_type}'"), - CheckErrorKind::ExpectedOptionalValue(found_value) => format!("expecting expression of type 'optional', found '{found_value}'"), - CheckErrorKind::ExpectedResponseValue(found_value) => format!("expecting expression of type 'response', found '{found_value}'"), - CheckErrorKind::ExpectedContractPrincipalValue(found_value) => format!("expecting contract principal value, found '{found_value}'"), - CheckErrorKind::CouldNotDetermineResponseOkType => "attempted to obtain 'ok' value from response, but 'ok' type is indeterminate".into(), - CheckErrorKind::CouldNotDetermineResponseErrType => "attempted to obtain 'err' value from response, but 'err' type is indeterminate".into(), - CheckErrorKind::CouldNotDetermineMatchTypes => "attempted to match on an (optional) or (response) type where either the some, ok, or err type is indeterminate. you may wish to use unwrap-panic or unwrap-err-panic instead.".into(), - CheckErrorKind::CouldNotDetermineType => "type of expression cannot be determined".into(), - CheckErrorKind::BadTupleFieldName => "invalid tuple field name".into(), - CheckErrorKind::ExpectedTuple(type_signature) => format!("expecting tuple, found '{type_signature}'"), - CheckErrorKind::NoSuchTupleField(field_name, tuple_signature) => format!("cannot find field '{field_name}' in tuple '{tuple_signature}'"), - CheckErrorKind::BadTupleConstruction(message) => format!("invalid tuple syntax: {message}"), - CheckErrorKind::NoSuchDataVariable(var_name) => format!("use of unresolved persisted variable '{var_name}'"), - CheckErrorKind::BadTransferSTXArguments => "STX transfer expects an int amount, from principal, to principal".into(), - CheckErrorKind::BadTransferFTArguments => "transfer expects an int amount, from principal, to principal".into(), - CheckErrorKind::BadTransferNFTArguments => "transfer expects an asset, from principal, to principal".into(), - CheckErrorKind::BadMintFTArguments => "mint expects a uint amount and from principal".into(), - CheckErrorKind::BadBurnFTArguments => "burn expects a uint amount and from principal".into(), - CheckErrorKind::BadMapName => "invalid map name".into(), + CheckErrorKind::ListTypesMustMatch => { + "expecting elements of same type in a list".into() + } + CheckErrorKind::TypeError(expected_type, found_type) => { + format!("expecting expression of type '{expected_type}', found '{found_type}'") + } + CheckErrorKind::TypeValueError(expected_type, found_value) => { + format!("expecting expression of type '{expected_type}', found '{found_value}'") + } + CheckErrorKind::UnionTypeError(expected_types, found_type) => format!( + "expecting expression of type {}, found '{}'", + formatted_expected_types(expected_types), + found_type + ), + CheckErrorKind::UnionTypeValueError(expected_types, found_type) => format!( + "expecting expression of type {}, found '{}'", + formatted_expected_types(expected_types), + found_type + ), + CheckErrorKind::ExpectedOptionalOrResponseValue(found_value) => format!( + "expecting expression of type 'optional' or 'response', found '{found_value}'" + ), + CheckErrorKind::ExpectedOptionalValue(found_value) => { + format!("expecting expression of type 'optional', found '{found_value}'") + } + CheckErrorKind::ExpectedResponseValue(found_value) => { + format!("expecting expression of type 'response', found '{found_value}'") + } + CheckErrorKind::ExpectedContractPrincipalValue(found_value) => { + format!("expecting contract principal value, found '{found_value}'") + } + CheckErrorKind::CouldNotDetermineType => { + "type of expression cannot be determined".into() + } + CheckErrorKind::ExpectedTuple(type_signature) => { + format!("expecting tuple, found '{type_signature}'") + } + CheckErrorKind::NoSuchTupleField(field_name, tuple_signature) => { + format!("cannot find field '{field_name}' in tuple '{tuple_signature}'") + } + CheckErrorKind::NoSuchDataVariable(var_name) => { + format!("use of unresolved persisted variable '{var_name}'") + } + CheckErrorKind::BadTransferSTXArguments => { + "STX transfer expects an int amount, from principal, to principal".into() + } + CheckErrorKind::BadTransferFTArguments => { + "transfer expects an int amount, from principal, to principal".into() + } + CheckErrorKind::BadTransferNFTArguments => { + "transfer expects an asset, from principal, to principal".into() + } + CheckErrorKind::BadMintFTArguments => { + "mint expects a uint amount and from principal".into() + } + CheckErrorKind::BadBurnFTArguments => { + "burn expects a uint amount and from principal".into() + } CheckErrorKind::NoSuchMap(map_name) => format!("use of unresolved map '{map_name}'"), CheckErrorKind::DefineFunctionBadSignature => "invalid function definition".into(), CheckErrorKind::BadFunctionName => "invalid function name".into(), - CheckErrorKind::BadMapTypeDefinition => "invalid map definition".into(), - CheckErrorKind::PublicFunctionMustReturnResponse(found_type) => format!("public functions must return an expression of type 'response', found '{found_type}'"), - CheckErrorKind::DefineVariableBadSignature => "invalid variable definition".into(), - CheckErrorKind::ReturnTypesMustMatch(type_1, type_2) => format!("detected two execution paths, returning two different expression types (got '{type_1}' and '{type_2}')"), - CheckErrorKind::NoSuchContract(contract_identifier) => format!("use of unresolved contract '{contract_identifier}'"), - CheckErrorKind::NoSuchPublicFunction(contract_identifier, function_name) => format!("contract '{contract_identifier}' has no public function '{function_name}'"), - CheckErrorKind::PublicFunctionNotReadOnly(contract_identifier, function_name) => format!("function '{contract_identifier}' in '{function_name}' is not read-only"), - CheckErrorKind::ContractAlreadyExists(contract_identifier) => format!("contract name '{contract_identifier}' conflicts with existing contract"), + CheckErrorKind::PublicFunctionMustReturnResponse(found_type) => format!( + "public functions must return an expression of type 'response', found '{found_type}'" + ), + CheckErrorKind::ReturnTypesMustMatch(type_1, type_2) => format!( + "detected two execution paths, returning two different expression types (got '{type_1}' and '{type_2}')" + ), + CheckErrorKind::NoSuchContract(contract_identifier) => { + format!("use of unresolved contract '{contract_identifier}'") + } + CheckErrorKind::NoSuchPublicFunction(contract_identifier, function_name) => { + format!("contract '{contract_identifier}' has no public function '{function_name}'") + } + CheckErrorKind::PublicFunctionNotReadOnly(contract_identifier, function_name) => { + format!("function '{contract_identifier}' in '{function_name}' is not read-only") + } + CheckErrorKind::ContractAlreadyExists(contract_identifier) => { + format!("contract name '{contract_identifier}' conflicts with existing contract") + } CheckErrorKind::ContractCallExpectName => "missing contract name for call".into(), - CheckErrorKind::ExpectedCallableType(found_type) => format!("expected a callable contract, found {found_type}"), - CheckErrorKind::NoSuchBlockInfoProperty(property_name) => format!("use of block unknown property '{property_name}'"), - CheckErrorKind::NoSuchBurnBlockInfoProperty(property_name) => format!("use of burn block unknown property '{property_name}'"), - CheckErrorKind::NoSuchStacksBlockInfoProperty(property_name) => format!("use of unknown stacks block property '{property_name}'"), - CheckErrorKind::NoSuchTenureInfoProperty(property_name) => format!("use of unknown tenure property '{property_name}'"), - CheckErrorKind::GetBlockInfoExpectPropertyName => "missing property name for block info introspection".into(), - CheckErrorKind::GetBurnBlockInfoExpectPropertyName => "missing property name for burn block info introspection".into(), - CheckErrorKind::GetStacksBlockInfoExpectPropertyName => "missing property name for stacks block info introspection".into(), - CheckErrorKind::GetTenureInfoExpectPropertyName => "missing property name for tenure info introspection".into(), - CheckErrorKind::NameAlreadyUsed(name) => format!("defining '{name}' conflicts with previous value"), - CheckErrorKind::ReservedWord(name) => format!("{name} is a reserved word"), - CheckErrorKind::NonFunctionApplication => "expecting expression of type function".into(), + CheckErrorKind::NoSuchBurnBlockInfoProperty(property_name) => { + format!("use of burn block unknown property '{property_name}'") + } + CheckErrorKind::NoSuchStacksBlockInfoProperty(property_name) => { + format!("use of unknown stacks block property '{property_name}'") + } + CheckErrorKind::GetBlockInfoExpectPropertyName => { + "missing property name for block info introspection".into() + } + CheckErrorKind::GetStacksBlockInfoExpectPropertyName => { + "missing property name for stacks block info introspection".into() + } + CheckErrorKind::GetTenureInfoExpectPropertyName => { + "missing property name for tenure info introspection".into() + } + CheckErrorKind::NameAlreadyUsed(name) => { + format!("defining '{name}' conflicts with previous value") + } + CheckErrorKind::NonFunctionApplication => { + "expecting expression of type function".into() + } CheckErrorKind::ExpectedListApplication => "expecting expression of type list".into(), - CheckErrorKind::ExpectedSequence(found_type) => format!("expecting expression of type 'list', 'buff', 'string-ascii' or 'string-utf8' - found '{found_type}'"), - CheckErrorKind::MaxLengthOverflow => format!("expecting a value <= {}", u32::MAX), + CheckErrorKind::ExpectedSequence(found_type) => format!( + "expecting expression of type 'list', 'buff', 'string-ascii' or 'string-utf8' - found '{found_type}'" + ), CheckErrorKind::BadLetSyntax => "invalid syntax of 'let'".into(), - CheckErrorKind::CircularReference(references) => format!("detected circular reference: ({})", references.join(", ")), - CheckErrorKind::BadSyntaxBinding(binding_error) => format!("invalid syntax binding: {}", &binding_error.message()), - CheckErrorKind::MaxContextDepthReached => "reached depth limit".into(), - CheckErrorKind::UndefinedVariable(var_name) => format!("use of unresolved variable '{var_name}'"), - CheckErrorKind::UndefinedFunction(var_name) => format!("use of unresolved function '{var_name}'"), - CheckErrorKind::RequiresAtLeastArguments(expected, found) => format!("expecting >= {expected} arguments, got {found}"), - CheckErrorKind::RequiresAtMostArguments(expected, found) => format!("expecting < {expected} arguments, got {found}"), - CheckErrorKind::IncorrectArgumentCount(expected_count, found_count) => format!("expecting {expected_count} arguments, got {found_count}"), - CheckErrorKind::IfArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'if' must match (got '{type_1}' and '{type_2}')"), - CheckErrorKind::MatchArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'match' must match (got '{type_1}' and '{type_2}')"), - CheckErrorKind::DefaultTypesMustMatch(type_1, type_2) => format!("expression types passed in 'default-to' must match (got '{type_1}' and '{type_2}')"), - CheckErrorKind::IllegalOrUnknownFunctionApplication(function_name) => format!("use of illegal / unresolved function '{function_name}"), - CheckErrorKind::UnknownFunction(function_name) => format!("use of unresolved function '{function_name}'"), - CheckErrorKind::TraitBasedContractCallInReadOnly => "use of trait based contract calls are not allowed in read-only context".into(), - CheckErrorKind::WriteAttemptedInReadOnly => "expecting read-only statements, detected a writing operation".into(), - CheckErrorKind::AtBlockClosureMustBeReadOnly => "(at-block ...) closures expect read-only statements, but detected a writing operation".into(), + CheckErrorKind::CircularReference(references) => { + format!("detected circular reference: ({})", references.join(", ")) + } + CheckErrorKind::BadSyntaxBinding(binding_error) => { + format!("invalid syntax binding: {}", &binding_error.message()) + } + CheckErrorKind::UndefinedVariable(var_name) => { + format!("use of unresolved variable '{var_name}'") + } + CheckErrorKind::UndefinedFunction(var_name) => { + format!("use of unresolved function '{var_name}'") + } + CheckErrorKind::RequiresAtLeastArguments(expected, found) => { + format!("expecting >= {expected} arguments, got {found}") + } + CheckErrorKind::RequiresAtMostArguments(expected, found) => { + format!("expecting < {expected} arguments, got {found}") + } + CheckErrorKind::IncorrectArgumentCount(expected_count, found_count) => { + format!("expecting {expected_count} arguments, got {found_count}") + } + CheckErrorKind::TraitBasedContractCallInReadOnly => { + "use of trait based contract calls are not allowed in read-only context".into() + } + CheckErrorKind::WriteAttemptedInReadOnly => { + "expecting read-only statements, detected a writing operation".into() + } CheckErrorKind::BadTokenName => "expecting an token name as an argument".into(), - CheckErrorKind::DefineNFTBadSignature => "(define-asset ...) expects an asset name and an asset identifier type signature as arguments".into(), - CheckErrorKind::NoSuchNFT(asset_name) => format!("tried to use asset function with a undefined asset ('{asset_name}')"), - CheckErrorKind::NoSuchFT(asset_name) => format!("tried to use token function with a undefined token ('{asset_name}')"), - CheckErrorKind::NoSuchTrait(contract_name, trait_name) => format!("use of unresolved trait {contract_name}.{trait_name}"), - CheckErrorKind::TraitReferenceUnknown(trait_name) => format!("use of undeclared trait <{trait_name}>"), - CheckErrorKind::TraitMethodUnknown(trait_name, func_name) => format!("method '{func_name}' unspecified in trait <{trait_name}>"), - CheckErrorKind::BadTraitImplementation(trait_name, func_name) => format!("invalid signature for method '{func_name}' regarding trait's specification <{trait_name}>"), - CheckErrorKind::ExpectedTraitIdentifier => "expecting expression of type trait identifier".into(), - CheckErrorKind::UnexpectedTraitOrFieldReference => "unexpected use of trait reference or field".into(), + CheckErrorKind::NoSuchNFT(asset_name) => { + format!("tried to use asset function with a undefined asset ('{asset_name}')") + } + CheckErrorKind::NoSuchFT(asset_name) => { + format!("tried to use token function with a undefined token ('{asset_name}')") + } + CheckErrorKind::TraitReferenceUnknown(trait_name) => { + format!("use of undeclared trait <{trait_name}>") + } + CheckErrorKind::TraitMethodUnknown(trait_name, func_name) => { + format!("method '{func_name}' unspecified in trait <{trait_name}>") + } + CheckErrorKind::BadTraitImplementation(trait_name, func_name) => format!( + "invalid signature for method '{func_name}' regarding trait's specification <{trait_name}>" + ), + CheckErrorKind::ExpectedTraitIdentifier => { + "expecting expression of type trait identifier".into() + } CheckErrorKind::DefineTraitBadSignature => "invalid trait definition".into(), - CheckErrorKind::DefineTraitDuplicateMethod(method_name) => format!("duplicate method name '{method_name}' in trait definition"), - CheckErrorKind::TraitReferenceNotAllowed => "trait references can not be stored".into(), + CheckErrorKind::DefineTraitDuplicateMethod(method_name) => { + format!("duplicate method name '{method_name}' in trait definition") + } CheckErrorKind::ContractOfExpectsTrait => "trait reference expected".into(), - CheckErrorKind::IncompatibleTrait(expected_trait, actual_trait) => format!("trait '{actual_trait}' is not a compatible with expected trait, '{expected_trait}'"), CheckErrorKind::InvalidCharactersDetected => "invalid characters detected".into(), CheckErrorKind::InvalidUTF8Encoding => "invalid UTF8 encoding".into(), CheckErrorKind::InvalidSecp65k1Signature => "invalid seckp256k1 signature".into(), - CheckErrorKind::TypeAlreadyAnnotatedFailure | CheckErrorKind::CheckerImplementationFailure => { - "internal error - please file an issue on https://github.com/stacks-network/stacks-blockchain".into() - }, - CheckErrorKind::UncheckedIntermediaryResponses => "intermediary responses in consecutive statements must be checked".into(), - CheckErrorKind::CostComputationFailed(s) => format!("contract cost computation failed: {s}"), - CheckErrorKind::CouldNotDetermineSerializationType => "could not determine the input type for the serialization function".into(), + CheckErrorKind::CostComputationFailed(s) => { + format!("contract cost computation failed: {s}") + } + CheckErrorKind::CouldNotDetermineSerializationType => { + "could not determine the input type for the serialization function".into() + } CheckErrorKind::ExecutionTimeExpired => "execution time expired".into(), } } @@ -804,9 +1534,6 @@ impl DiagnosableError for CheckErrorKind { "traits should be either defined, with define-trait, or imported, with use-trait." .into(), ), - CheckErrorKind::NoSuchBlockInfoProperty(_) => Some( - "properties available: time, header-hash, burnchain-header-hash, vrf-seed".into(), - ), _ => None, } } diff --git a/clarity-types/src/errors/mod.rs b/clarity-types/src/errors/mod.rs index 370a93f88db..4e9948dccf3 100644 --- a/clarity-types/src/errors/mod.rs +++ b/clarity-types/src/errors/mod.rs @@ -20,6 +20,7 @@ pub mod lexer; use std::{error, fmt}; +use analysis::CommonCheckErrorKind; pub use analysis::{CheckErrorKind, StaticCheckError}; pub use ast::{ParseError, ParseErrorKind, ParseResult}; pub use cost::CostErrors; @@ -274,6 +275,14 @@ impl From for VmExecutionError { } } +// TODO: remove. CommonCheckErrorKind shouldn't be used in the public API. +// So there shouldn't be any need to convert it to a VmExecutionError. +impl From for VmExecutionError { + fn from(err: CommonCheckErrorKind) -> Self { + VmExecutionError::Unchecked(err.into()) + } +} + impl From for VmExecutionError { fn from(err: CostErrors) -> Self { match err { @@ -300,9 +309,11 @@ impl From for VmExecutionError { } } -impl From<(CheckErrorKind, &SymbolicExpression)> for VmExecutionError { - fn from(err: (CheckErrorKind, &SymbolicExpression)) -> Self { - VmExecutionError::Unchecked(err.0) +// TODO: remove. CommonCheckErrorKind shouldn't be used in the public API. +// So there shouldn't be any need to convert it to a VmExecutionError. +impl From<(CommonCheckErrorKind, &SymbolicExpression)> for VmExecutionError { + fn from(err: (CommonCheckErrorKind, &SymbolicExpression)) -> Self { + VmExecutionError::Unchecked(err.0.into()) } } diff --git a/clarity-types/src/tests/types/mod.rs b/clarity-types/src/tests/types/mod.rs index ef0a023a60b..0b9329d93ed 100644 --- a/clarity-types/src/tests/types/mod.rs +++ b/clarity-types/src/tests/types/mod.rs @@ -19,6 +19,7 @@ use rstest::rstest; use stacks_common::types::StacksEpochId; use crate::VmExecutionError; +use crate::errors::analysis::CommonCheckErrorKind; use crate::errors::{CheckErrorKind, RuntimeError, VmInternalError}; use crate::types::{ ASCIIData, BuffData, CharType, ListTypeData, MAX_VALUE_SIZE, PrincipalData, @@ -38,7 +39,7 @@ fn test_constructors() { ); assert_eq!( ListTypeData::new_list(TypeSignature::IntType, MAX_VALUE_SIZE), - Err(CheckErrorKind::ValueTooLarge) + Err(CommonCheckErrorKind::ValueTooLarge) ); assert_eq!( diff --git a/clarity-types/src/tests/types/signatures.rs b/clarity-types/src/tests/types/signatures.rs index 6fecdd77767..a41dbf6ed38 100644 --- a/clarity-types/src/tests/types/signatures.rs +++ b/clarity-types/src/tests/types/signatures.rs @@ -14,7 +14,7 @@ // along with this program. If not, see . use std::collections::HashSet; -use crate::errors::CheckErrorKind; +use crate::errors::analysis::CommonCheckErrorKind; use crate::representations::CONTRACT_MAX_NAME_LENGTH; use crate::types::TypeSignature::{BoolType, IntType, ListUnionType, UIntType}; use crate::types::signatures::{CallableSubtype, TypeSignature}; @@ -43,7 +43,7 @@ fn test_buffer_length_try_from_u32_trait() { assert_eq!(MAX_VALUE_SIZE, buffer.get_value()); let err = BufferLength::try_from(MAX_VALUE_SIZE + 1).unwrap_err(); - assert_eq!(CheckErrorKind::ValueTooLarge, err); + assert_eq!(CommonCheckErrorKind::ValueTooLarge, err); } #[test] @@ -55,7 +55,7 @@ fn test_buffer_length_try_from_usize_trait() { assert_eq!(MAX_VALUE_SIZE, buffer.get_value()); let err = BufferLength::try_from(MAX_VALUE_SIZE as usize + 1).unwrap_err(); - assert_eq!(CheckErrorKind::ValueTooLarge, err); + assert_eq!(CommonCheckErrorKind::ValueTooLarge, err); } #[test] @@ -67,10 +67,10 @@ fn test_buffer_length_try_from_i128_trait() { assert_eq!(MAX_VALUE_SIZE, buffer.get_value()); let err = BufferLength::try_from(MAX_VALUE_SIZE as i128 + 1).unwrap_err(); - assert_eq!(CheckErrorKind::ValueTooLarge, err); + assert_eq!(CommonCheckErrorKind::ValueTooLarge, err); let err = BufferLength::try_from(-1_i128).unwrap_err(); - assert_eq!(CheckErrorKind::ValueOutOfBounds, err); + assert_eq!(CommonCheckErrorKind::ValueOutOfBounds, err); } #[test] @@ -229,7 +229,7 @@ fn test_string_utf8_length_try_from_u32_trait() { assert_eq!(MAX_UTF8_VALUE_SIZE, string.get_value()); let err = StringUTF8Length::try_from(MAX_UTF8_VALUE_SIZE + 1).unwrap_err(); - assert_eq!(CheckErrorKind::ValueTooLarge, err); + assert_eq!(CommonCheckErrorKind::ValueTooLarge, err); } #[test] @@ -244,7 +244,7 @@ fn test_string_utf8_length_try_from_usize_trait() { assert_eq!(MAX_UTF8_VALUE_SIZE, string.get_value()); let err = StringUTF8Length::try_from(MAX_UTF8_VALUE_SIZE as usize + 1).unwrap_err(); - assert_eq!(CheckErrorKind::ValueTooLarge, err); + assert_eq!(CommonCheckErrorKind::ValueTooLarge, err); } #[test] @@ -259,10 +259,10 @@ fn test_string_utf8_length_try_from_i128_trait() { assert_eq!(MAX_UTF8_VALUE_SIZE, string.get_value()); let err = StringUTF8Length::try_from(MAX_UTF8_VALUE_SIZE as i128 + 1).unwrap_err(); - assert_eq!(CheckErrorKind::ValueTooLarge, err); + assert_eq!(CommonCheckErrorKind::ValueTooLarge, err); let err = StringUTF8Length::try_from(-1_i128).unwrap_err(); - assert_eq!(CheckErrorKind::ValueOutOfBounds, err); + assert_eq!(CommonCheckErrorKind::ValueOutOfBounds, err); } #[test] @@ -826,11 +826,11 @@ fn test_least_supertype() { for pair in bad_pairs { matches!( TypeSignature::least_supertype_v2_1(&pair.0, &pair.1).unwrap_err(), - CheckErrorKind::TypeError(..) + CommonCheckErrorKind::TypeError(..) ); matches!( TypeSignature::least_supertype_v2_1(&pair.1, &pair.0).unwrap_err(), - CheckErrorKind::TypeError(..) + CommonCheckErrorKind::TypeError(..) ); } } diff --git a/clarity-types/src/types/mod.rs b/clarity-types/src/types/mod.rs index 42ff94e4a9c..9e193391723 100644 --- a/clarity-types/src/types/mod.rs +++ b/clarity-types/src/types/mod.rs @@ -36,6 +36,7 @@ pub use self::signatures::{ AssetIdentifier, BufferLength, ListTypeData, SequenceSubtype, StringSubtype, StringUTF8Length, TupleTypeSignature, TypeSignature, }; +use crate::errors::analysis::CommonCheckErrorKind; use crate::errors::{CheckErrorKind, InterpreterResult as Result, RuntimeError, VmInternalError}; use crate::representations::{ClarityName, ContractName, SymbolicExpression}; @@ -700,7 +701,7 @@ impl fmt::Display for UTF8Data { } pub trait SequencedValue { - fn type_signature(&self) -> std::result::Result; + fn type_signature(&self) -> std::result::Result; fn items(&self) -> &Vec; @@ -725,7 +726,7 @@ impl SequencedValue for ListData { self.data.drain(..).collect() } - fn type_signature(&self) -> std::result::Result { + fn type_signature(&self) -> std::result::Result { Ok(TypeSignature::SequenceType(SequenceSubtype::ListType( self.type_signature.clone(), ))) @@ -745,9 +746,11 @@ impl SequencedValue for BuffData { self.data.drain(..).collect() } - fn type_signature(&self) -> std::result::Result { + fn type_signature(&self) -> std::result::Result { let buff_length = BufferLength::try_from(self.data.len()).map_err(|_| { - CheckErrorKind::Expects("ERROR: Too large of a buffer successfully constructed.".into()) + CommonCheckErrorKind::Expects( + "ERROR: Too large of a buffer successfully constructed.".into(), + ) })?; Ok(TypeSignature::SequenceType(SequenceSubtype::BufferType( buff_length, @@ -768,9 +771,11 @@ impl SequencedValue for ASCIIData { self.data.drain(..).collect() } - fn type_signature(&self) -> std::result::Result { + fn type_signature(&self) -> std::result::Result { let buff_length = BufferLength::try_from(self.data.len()).map_err(|_| { - CheckErrorKind::Expects("ERROR: Too large of a buffer successfully constructed.".into()) + CommonCheckErrorKind::Expects( + "ERROR: Too large of a buffer successfully constructed.".into(), + ) })?; Ok(TypeSignature::SequenceType(SequenceSubtype::StringType( StringSubtype::ASCII(buff_length), @@ -794,9 +799,11 @@ impl SequencedValue> for UTF8Data { self.data.drain(..).collect() } - fn type_signature(&self) -> std::result::Result { + fn type_signature(&self) -> std::result::Result { let str_len = StringUTF8Length::try_from(self.data.len()).map_err(|_| { - CheckErrorKind::Expects("ERROR: Too large of a buffer successfully constructed.".into()) + CommonCheckErrorKind::Expects( + "ERROR: Too large of a buffer successfully constructed.".into(), + ) })?; Ok(TypeSignature::SequenceType(SequenceSubtype::StringType( StringSubtype::UTF8(str_len), @@ -812,19 +819,19 @@ impl SequencedValue> for UTF8Data { } impl OptionalData { - pub fn type_signature(&self) -> std::result::Result { + pub fn type_signature(&self) -> std::result::Result { let type_result = match self.data { Some(ref v) => TypeSignature::new_option(TypeSignature::type_of(v)?), None => TypeSignature::new_option(TypeSignature::NoType), }; type_result.map_err(|_| { - CheckErrorKind::Expects("Should not have constructed too large of a type.".into()) + CommonCheckErrorKind::Expects("Should not have constructed too large of a type.".into()) }) } } impl ResponseData { - pub fn type_signature(&self) -> std::result::Result { + pub fn type_signature(&self) -> std::result::Result { let type_result = match self.committed { true => TypeSignature::new_response( TypeSignature::type_of(&self.data)?, @@ -836,7 +843,7 @@ impl ResponseData { ), }; type_result.map_err(|_| { - CheckErrorKind::Expects("Should not have constructed too large of a type.".into()) + CommonCheckErrorKind::Expects("Should not have constructed too large of a type.".into()) }) } } diff --git a/clarity-types/src/types/serialization.rs b/clarity-types/src/types/serialization.rs index 929b2e43136..019beb38f49 100644 --- a/clarity-types/src/types/serialization.rs +++ b/clarity-types/src/types/serialization.rs @@ -23,6 +23,7 @@ use stacks_common::util::hash::{hex_bytes, to_hex}; use stacks_common::util::retry::BoundReader; use super::{ListTypeData, TupleTypeSignature}; +use crate::errors::analysis::{CommonCheckErrorKind, StaticCheckErrorKind}; use crate::errors::{CheckErrorKind, IncomparableError, VmInternalError}; use crate::representations::{ClarityName, ContractName, MAX_STRING_LEN}; use crate::types::{ @@ -128,6 +129,14 @@ impl From for SerializationError { } } +// TODO: remove. CommonCheckErrorKind shouldn't be used in the public API. +// So there shouldn't be any need to convert it to a SerializationError. +impl From for SerializationError { + fn from(e: CommonCheckErrorKind) -> Self { + SerializationError::BadTypeError(CheckErrorKind::from(e)) + } +} + define_u8_enum!(TypePrefix { Int = 0, UInt = 1, @@ -394,7 +403,7 @@ impl TypeSignature { /// size of a `(buff 1024*1024)` is `1+1024*1024` because of the /// type prefix byte. However, that is 1 byte larger than the maximum /// buffer size in Clarity. - pub fn max_serialized_size(&self) -> Result { + pub fn max_serialized_size(&self) -> Result { let type_prefix_size = 1; let max_output_size = match self { @@ -405,7 +414,7 @@ impl TypeSignature { // `some` or similar with `result` types). So, when // serializing an object with a `NoType`, the other // branch should always be used. - return Err(CheckErrorKind::CouldNotDetermineSerializationType); + return Err(StaticCheckErrorKind::CouldNotDetermineSerializationType); } TypeSignature::IntType => 16, TypeSignature::UIntType => 16, @@ -417,14 +426,14 @@ impl TypeSignature { .get_max_len() .checked_mul(list_type.get_list_item_type().max_serialized_size()?) .and_then(|x| x.checked_add(list_length_encode)) - .ok_or_else(|| CheckErrorKind::ValueTooLarge)? + .ok_or_else(|| StaticCheckErrorKind::ValueTooLarge)? } TypeSignature::SequenceType(SequenceSubtype::BufferType(buff_length)) => { // u32 length as big-endian bytes let buff_length_encode = 4; u32::from(buff_length) .checked_add(buff_length_encode) - .ok_or_else(|| CheckErrorKind::ValueTooLarge)? + .ok_or_else(|| StaticCheckErrorKind::ValueTooLarge)? } TypeSignature::SequenceType(SequenceSubtype::StringType(StringSubtype::ASCII( length, @@ -434,7 +443,7 @@ impl TypeSignature { // ascii is 1-byte per character u32::from(length) .checked_add(str_length_encode) - .ok_or_else(|| CheckErrorKind::ValueTooLarge)? + .ok_or_else(|| StaticCheckErrorKind::ValueTooLarge)? } TypeSignature::SequenceType(SequenceSubtype::StringType(StringSubtype::UTF8( length, @@ -445,7 +454,7 @@ impl TypeSignature { u32::from(length) .checked_mul(4) .and_then(|x| x.checked_add(str_length_encode)) - .ok_or_else(|| CheckErrorKind::ValueTooLarge)? + .ok_or_else(|| StaticCheckErrorKind::ValueTooLarge)? } TypeSignature::PrincipalType | TypeSignature::CallableType(_) @@ -468,7 +477,7 @@ impl TypeSignature { .checked_add(1) // length of key-name .and_then(|x| x.checked_add(key.len() as u32)) // ClarityName is ascii-only, so 1 byte per length .and_then(|x| x.checked_add(value_size)) - .ok_or_else(|| CheckErrorKind::ValueTooLarge)?; + .ok_or_else(|| StaticCheckErrorKind::ValueTooLarge)?; } total_size } @@ -477,7 +486,7 @@ impl TypeSignature { Ok(size) => size, // if NoType, then this is just serializing a none // value, which is only the type prefix - Err(CheckErrorKind::CouldNotDetermineSerializationType) => 0, + Err(StaticCheckErrorKind::CouldNotDetermineSerializationType) => 0, Err(e) => return Err(e), } } @@ -485,17 +494,17 @@ impl TypeSignature { let (ok_type, err_type) = response_types.as_ref(); let (ok_type_max_size, no_ok_type) = match ok_type.max_serialized_size() { Ok(size) => (size, false), - Err(CheckErrorKind::CouldNotDetermineSerializationType) => (0, true), + Err(StaticCheckErrorKind::CouldNotDetermineSerializationType) => (0, true), Err(e) => return Err(e), }; let err_type_max_size = match err_type.max_serialized_size() { Ok(size) => size, - Err(CheckErrorKind::CouldNotDetermineSerializationType) => { + Err(StaticCheckErrorKind::CouldNotDetermineSerializationType) => { if no_ok_type { // if both the ok type and the error type are NoType, - // throw a CheckErrorKind. This should not be possible, but the check + // throw a StaticCheckErrorKind. This should not be possible, but the check // is done out of caution. - return Err(CheckErrorKind::CouldNotDetermineSerializationType); + return Err(StaticCheckErrorKind::CouldNotDetermineSerializationType); } else { 0 } @@ -505,13 +514,13 @@ impl TypeSignature { cmp::max(ok_type_max_size, err_type_max_size) } TypeSignature::ListUnionType(_) => { - return Err(CheckErrorKind::CouldNotDetermineSerializationType); + return Err(StaticCheckErrorKind::CouldNotDetermineSerializationType); } }; max_output_size .checked_add(type_prefix_size) - .ok_or_else(|| CheckErrorKind::ValueTooLarge) + .ok_or_else(|| StaticCheckErrorKind::ValueTooLarge) } } diff --git a/clarity-types/src/types/signatures.rs b/clarity-types/src/types/signatures.rs index 5f7cee23fb1..7a716fae88e 100644 --- a/clarity-types/src/types/signatures.rs +++ b/clarity-types/src/types/signatures.rs @@ -23,6 +23,7 @@ use serde::{Deserialize, Serialize}; use stacks_common::types::StacksEpochId; use crate::errors::CheckErrorKind; +use crate::errors::analysis::{CommonCheckErrorKind, StaticCheckErrorKind}; use crate::representations::{CONTRACT_MAX_NAME_LENGTH, ClarityName, ContractName}; use crate::types::{ CharType, MAX_TO_ASCII_BUFFER_LEN, MAX_TO_ASCII_RESULT_LEN, MAX_TYPE_DEPTH, @@ -121,11 +122,11 @@ impl BufferLength { /// /// This function is primarily intended for internal runtime use, /// and serves as the central place for all integer validation logic. - fn try_from_i128(data: i128) -> Result { + fn try_from_i128(data: i128) -> Result { if data > (MAX_VALUE_SIZE as i128) { - Err(CheckErrorKind::ValueTooLarge) + Err(CommonCheckErrorKind::ValueTooLarge) } else if data < 0 { - Err(CheckErrorKind::ValueOutOfBounds) + Err(CommonCheckErrorKind::ValueOutOfBounds) } else { Ok(BufferLength(data as u32)) } @@ -161,22 +162,22 @@ impl From for u32 { } impl TryFrom for BufferLength { - type Error = CheckErrorKind; - fn try_from(data: u32) -> Result { + type Error = CommonCheckErrorKind; + fn try_from(data: u32) -> Result { Self::try_from(data as i128) } } impl TryFrom for BufferLength { - type Error = CheckErrorKind; - fn try_from(data: usize) -> Result { + type Error = CommonCheckErrorKind; + fn try_from(data: usize) -> Result { Self::try_from(data as i128) } } impl TryFrom for BufferLength { - type Error = CheckErrorKind; - fn try_from(data: i128) -> Result { + type Error = CommonCheckErrorKind; + fn try_from(data: i128) -> Result { Self::try_from_i128(data) } } @@ -202,11 +203,11 @@ impl StringUTF8Length { /// /// This function is primarily intended for internal runtime use, /// and serves as the central place for all integer validation logic. - fn try_from_i128(value: i128) -> Result { + fn try_from_i128(value: i128) -> Result { if value > MAX_UTF8_VALUE_SIZE as i128 { - Err(CheckErrorKind::ValueTooLarge) + Err(CommonCheckErrorKind::ValueTooLarge) } else if value < 0 { - Err(CheckErrorKind::ValueOutOfBounds) + Err(CommonCheckErrorKind::ValueOutOfBounds) } else { Ok(StringUTF8Length(value as u32)) } @@ -242,22 +243,22 @@ impl From for u32 { } impl TryFrom for StringUTF8Length { - type Error = CheckErrorKind; - fn try_from(data: u32) -> Result { + type Error = CommonCheckErrorKind; + fn try_from(data: u32) -> Result { Self::try_from(data as i128) } } impl TryFrom for StringUTF8Length { - type Error = CheckErrorKind; - fn try_from(data: usize) -> Result { + type Error = CommonCheckErrorKind; + fn try_from(data: usize) -> Result { Self::try_from(data as i128) } } impl TryFrom for StringUTF8Length { - type Error = CheckErrorKind; - fn try_from(data: i128) -> Result { + type Error = CommonCheckErrorKind; + fn try_from(data: i128) -> Result { Self::try_from_i128(data) } } @@ -358,10 +359,10 @@ impl ListTypeData { pub fn new_list( entry_type: TypeSignature, max_len: u32, - ) -> Result { + ) -> Result { let would_be_depth = 1 + entry_type.depth(); if would_be_depth > MAX_TYPE_DEPTH { - return Err(CheckErrorKind::TypeSignatureTooDeep); + return Err(CommonCheckErrorKind::TypeSignatureTooDeep); } let list_data = ListTypeData { @@ -370,9 +371,9 @@ impl ListTypeData { }; let would_be_size = list_data .inner_size()? - .ok_or_else(|| CheckErrorKind::ValueTooLarge)?; + .ok_or_else(|| CommonCheckErrorKind::ValueTooLarge)?; if would_be_size > MAX_VALUE_SIZE { - Err(CheckErrorKind::ValueTooLarge) + Err(CommonCheckErrorKind::ValueTooLarge) } else { Ok(list_data) } @@ -400,13 +401,13 @@ impl ListTypeData { } impl TypeSignature { - pub fn new_option(inner_type: TypeSignature) -> Result { + pub fn new_option(inner_type: TypeSignature) -> Result { let new_size = WRAPPER_VALUE_SIZE + inner_type.size()?; let new_depth = 1 + inner_type.depth(); if new_size > MAX_VALUE_SIZE { - Err(CheckErrorKind::ValueTooLarge) + Err(CommonCheckErrorKind::ValueTooLarge) } else if new_depth > MAX_TYPE_DEPTH { - Err(CheckErrorKind::TypeSignatureTooDeep) + Err(CommonCheckErrorKind::TypeSignatureTooDeep) } else { Ok(OptionalType(Box::new(inner_type))) } @@ -415,14 +416,14 @@ impl TypeSignature { pub fn new_response( ok_type: TypeSignature, err_type: TypeSignature, - ) -> Result { + ) -> Result { let new_size = WRAPPER_VALUE_SIZE + cmp::max(ok_type.size()?, err_type.size()?); let new_depth = 1 + cmp::max(ok_type.depth(), err_type.depth()); if new_size > MAX_VALUE_SIZE { - Err(CheckErrorKind::ValueTooLarge) + Err(CommonCheckErrorKind::ValueTooLarge) } else if new_depth > MAX_TYPE_DEPTH { - Err(CheckErrorKind::TypeSignatureTooDeep) + Err(CommonCheckErrorKind::TypeSignatureTooDeep) } else { Ok(ResponseType(Box::new((ok_type, err_type)))) } @@ -436,7 +437,7 @@ impl TypeSignature { &TypeSignature::NoType == self } - pub fn admits(&self, epoch: &StacksEpochId, x: &Value) -> Result { + pub fn admits(&self, epoch: &StacksEpochId, x: &Value) -> Result { let x_type = TypeSignature::type_of(x)?; self.admits_type(epoch, &x_type) } @@ -445,7 +446,7 @@ impl TypeSignature { &self, epoch: &StacksEpochId, other: &TypeSignature, - ) -> Result { + ) -> Result { match epoch { StacksEpochId::Epoch20 | StacksEpochId::Epoch2_05 => self.admits_type_v2_0(other), StacksEpochId::Epoch21 @@ -457,13 +458,13 @@ impl TypeSignature { | StacksEpochId::Epoch31 | StacksEpochId::Epoch32 | StacksEpochId::Epoch33 => self.admits_type_v2_1(other), - StacksEpochId::Epoch10 => { - Err(CheckErrorKind::Expects("epoch 1.0 not supported".into())) - } + StacksEpochId::Epoch10 => Err(CommonCheckErrorKind::Expects( + "epoch 1.0 not supported".into(), + )), } } - pub fn admits_type_v2_0(&self, other: &TypeSignature) -> Result { + pub fn admits_type_v2_0(&self, other: &TypeSignature) -> Result { match self { SequenceType(SequenceSubtype::ListType(my_list_type)) => { if let SequenceType(SequenceSubtype::ListType(other_list_type)) = other { @@ -545,18 +546,18 @@ impl TypeSignature { Ok(false) } } - NoType => Err(CheckErrorKind::CouldNotDetermineType), - CallableType(_) => Err(CheckErrorKind::Expects( + NoType => Err(CommonCheckErrorKind::CouldNotDetermineType), + CallableType(_) => Err(CommonCheckErrorKind::Expects( "CallableType should not be used in epoch v2.0".into(), )), - ListUnionType(_) => Err(CheckErrorKind::Expects( + ListUnionType(_) => Err(CommonCheckErrorKind::Expects( "ListUnionType should not be used in epoch v2.0".into(), )), _ => Ok(other == self), } } - fn admits_type_v2_1(&self, other: &TypeSignature) -> Result { + fn admits_type_v2_1(&self, other: &TypeSignature) -> Result { let other = match other.concretize() { Ok(other) => other, Err(_) => { @@ -645,7 +646,7 @@ impl TypeSignature { Ok(false) } } - NoType => Err(CheckErrorKind::CouldNotDetermineType), + NoType => Err(CommonCheckErrorKind::CouldNotDetermineType), _ => Ok(&other == self), } } @@ -702,7 +703,7 @@ impl TypeSignature { /// Concretize the type. The input to this method may include /// `ListUnionType` and the `CallableType` variant for a `principal. /// This method turns these "temporary" types into actual types. - pub fn concretize(&self) -> Result { + pub fn concretize(&self) -> Result { match self { ListUnionType(types) => { let mut is_trait = None; @@ -711,7 +712,7 @@ impl TypeSignature { match partial { CallableSubtype::Principal(_) => { if is_trait.is_some() { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::CallableType(partial.clone())), Box::new(TypeSignature::PrincipalType), )); @@ -721,7 +722,7 @@ impl TypeSignature { } CallableSubtype::Trait(t) => { if is_principal { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::CallableType(partial.clone())), )); @@ -744,12 +745,12 @@ impl TypeSignature { } impl TryFrom> for TupleTypeSignature { - type Error = CheckErrorKind; + type Error = CommonCheckErrorKind; fn try_from( type_data: Vec<(ClarityName, TypeSignature)>, - ) -> Result { + ) -> Result { if type_data.is_empty() { - return Err(CheckErrorKind::EmptyTuplesNotAllowed); + return Err(CommonCheckErrorKind::EmptyTuplesNotAllowed); } let mut type_map = BTreeMap::new(); @@ -757,7 +758,7 @@ impl TryFrom> for TupleTypeSignature { if let Entry::Vacant(e) = type_map.entry(name.clone()) { e.insert(type_info); } else { - return Err(CheckErrorKind::NameAlreadyUsed(name.into())); + return Err(CommonCheckErrorKind::NameAlreadyUsed(name.into())); } } TupleTypeSignature::try_from(type_map) @@ -765,25 +766,25 @@ impl TryFrom> for TupleTypeSignature { } impl TryFrom> for TupleTypeSignature { - type Error = CheckErrorKind; + type Error = CommonCheckErrorKind; fn try_from( type_map: BTreeMap, - ) -> Result { + ) -> Result { if type_map.is_empty() { - return Err(CheckErrorKind::EmptyTuplesNotAllowed); + return Err(CommonCheckErrorKind::EmptyTuplesNotAllowed); } for child_sig in type_map.values() { if (1 + child_sig.depth()) > MAX_TYPE_DEPTH { - return Err(CheckErrorKind::TypeSignatureTooDeep); + return Err(CommonCheckErrorKind::TypeSignatureTooDeep); } } let type_map = Arc::new(type_map.into_iter().collect()); let result = TupleTypeSignature { type_map }; let would_be_size = result .inner_size()? - .ok_or_else(|| CheckErrorKind::ValueTooLarge)?; + .ok_or_else(|| CommonCheckErrorKind::ValueTooLarge)?; if would_be_size > MAX_VALUE_SIZE { - Err(CheckErrorKind::ValueTooLarge) + Err(CommonCheckErrorKind::ValueTooLarge) } else { Ok(result) } @@ -813,7 +814,7 @@ impl TupleTypeSignature { &self, epoch: &StacksEpochId, other: &TupleTypeSignature, - ) -> Result { + ) -> Result { if self.type_map.len() != other.type_map.len() { return Ok(false); } @@ -923,7 +924,7 @@ impl TypeSignature { epoch: &StacksEpochId, a: &TypeSignature, b: &TypeSignature, - ) -> Result { + ) -> Result { if a.is_no_type() { Ok(b.clone()) } else if b.is_no_type() { @@ -974,7 +975,7 @@ impl TypeSignature { epoch: &StacksEpochId, a: &TypeSignature, b: &TypeSignature, - ) -> Result { + ) -> Result { match epoch { StacksEpochId::Epoch20 | StacksEpochId::Epoch2_05 => Self::least_supertype_v2_0(a, b), StacksEpochId::Epoch21 @@ -986,16 +987,16 @@ impl TypeSignature { | StacksEpochId::Epoch31 | StacksEpochId::Epoch32 | StacksEpochId::Epoch33 => Self::least_supertype_v2_1(a, b), - StacksEpochId::Epoch10 => { - Err(CheckErrorKind::Expects("epoch 1.0 not supported".into())) - } + StacksEpochId::Epoch10 => Err(CommonCheckErrorKind::Expects( + "epoch 1.0 not supported".into(), + )), } } pub fn least_supertype_v2_0( a: &TypeSignature, b: &TypeSignature, - ) -> Result { + ) -> Result { match (a, b) { ( TupleType(TupleTypeSignature { type_map: types_a }), @@ -1003,7 +1004,7 @@ impl TypeSignature { ) => { let mut type_map_out = BTreeMap::new(); for (name, entry_a) in types_a.iter() { - let entry_b = types_b.get(name).ok_or(CheckErrorKind::TypeError( + let entry_b = types_b.get(name).ok_or(CommonCheckErrorKind::TypeError( Box::new(a.clone()), Box::new(b.clone()), ))?; @@ -1012,7 +1013,7 @@ impl TypeSignature { } Ok(TupleTypeSignature::try_from(type_map_out) .map(|x| x.into()) - .map_err(|_| CheckErrorKind::SupertypeTooLarge)?) + .map_err(|_| CommonCheckErrorKind::SupertypeTooLarge)?) } ( SequenceType(SequenceSubtype::ListType(ListTypeData { @@ -1033,7 +1034,7 @@ impl TypeSignature { }; let max_len = cmp::max(len_a, len_b); Ok(Self::list_of(entry_type, *max_len) - .map_err(|_| CheckErrorKind::SupertypeTooLarge)?) + .map_err(|_| CommonCheckErrorKind::SupertypeTooLarge)?) } (ResponseType(resp_a), ResponseType(resp_b)) => { let ok_type = @@ -1092,7 +1093,7 @@ impl TypeSignature { if x == y { Ok(x.clone()) } else { - Err(CheckErrorKind::TypeError( + Err(CommonCheckErrorKind::TypeError( Box::new(a.clone()), Box::new(b.clone()), )) @@ -1104,7 +1105,7 @@ impl TypeSignature { pub fn least_supertype_v2_1( a: &TypeSignature, b: &TypeSignature, - ) -> Result { + ) -> Result { match (a, b) { ( TupleType(TupleTypeSignature { type_map: types_a }), @@ -1112,7 +1113,7 @@ impl TypeSignature { ) => { let mut type_map_out = BTreeMap::new(); for (name, entry_a) in types_a.iter() { - let entry_b = types_b.get(name).ok_or(CheckErrorKind::TypeError( + let entry_b = types_b.get(name).ok_or(CommonCheckErrorKind::TypeError( Box::new(a.clone()), Box::new(b.clone()), ))?; @@ -1121,7 +1122,7 @@ impl TypeSignature { } Ok(TupleTypeSignature::try_from(type_map_out) .map(|x| x.into()) - .map_err(|_| CheckErrorKind::SupertypeTooLarge)?) + .map_err(|_| CommonCheckErrorKind::SupertypeTooLarge)?) } ( SequenceType(SequenceSubtype::ListType(ListTypeData { @@ -1142,7 +1143,7 @@ impl TypeSignature { }; let max_len = cmp::max(len_a, len_b); Ok(Self::list_of(entry_type, *max_len) - .map_err(|_| CheckErrorKind::SupertypeTooLarge)?) + .map_err(|_| CommonCheckErrorKind::SupertypeTooLarge)?) } (ResponseType(resp_a), ResponseType(resp_b)) => { let ok_type = @@ -1223,7 +1224,7 @@ impl TypeSignature { if all_principals { Ok(PrincipalType) } else { - Err(CheckErrorKind::TypeError( + Err(CommonCheckErrorKind::TypeError( Box::new(a.clone()), Box::new(b.clone()), )) @@ -1236,7 +1237,7 @@ impl TypeSignature { if x == y { Ok(x.clone()) } else { - Err(CheckErrorKind::TypeError( + Err(CommonCheckErrorKind::TypeError( Box::new(a.clone()), Box::new(b.clone()), )) @@ -1248,7 +1249,7 @@ impl TypeSignature { pub fn list_of( item_type: TypeSignature, max_len: u32, - ) -> Result { + ) -> Result { ListTypeData::new_list(item_type, max_len).map(|x| x.into()) } @@ -1259,7 +1260,7 @@ impl TypeSignature { } } - pub fn type_of(x: &Value) -> Result { + pub fn type_of(x: &Value) -> Result { let out = match x { Value::Principal(_) => PrincipalType, Value::Int(_v) => IntType, @@ -1288,7 +1289,7 @@ impl TypeSignature { Ok(out) } - pub fn literal_type_of(x: &Value) -> Result { + pub fn literal_type_of(x: &Value) -> Result { match x { Value::Principal(PrincipalData::Contract(contract_id)) => Ok(CallableType( CallableSubtype::Principal(contract_id.clone()), @@ -1299,18 +1300,21 @@ impl TypeSignature { // Checks if resulting type signature is of valid size. pub fn construct_parent_list_type(args: &[Value]) -> Result { - let children_types: Result, CheckErrorKind> = + let children_types: Result, CommonCheckErrorKind> = args.iter().map(TypeSignature::type_of).collect(); - TypeSignature::parent_list_type(&children_types?) + Ok(TypeSignature::parent_list_type(&children_types?)?) } - pub fn parent_list_type(children: &[TypeSignature]) -> Result { + pub fn parent_list_type( + children: &[TypeSignature], + ) -> Result { if let Some((first, rest)) = children.split_first() { let mut current_entry_type = first.clone(); for next_entry in rest.iter() { current_entry_type = Self::least_supertype_v2_1(¤t_entry_type, next_entry)?; } - let len = u32::try_from(children.len()).map_err(|_| CheckErrorKind::ValueTooLarge)?; + let len = + u32::try_from(children.len()).map_err(|_| CommonCheckErrorKind::ValueTooLarge)?; ListTypeData::new_list(current_entry_type, len) } else { Ok(TypeSignature::empty_list()) @@ -1350,16 +1354,16 @@ impl TypeSignature { } } - pub fn size(&self) -> Result { + pub fn size(&self) -> Result { self.inner_size()?.ok_or_else(|| { - CheckErrorKind::Expects( + CommonCheckErrorKind::Expects( "FAIL: .size() overflowed on too large of a type. construction should have failed!" .into(), ) }) } - fn inner_size(&self) -> Result, CheckErrorKind> { + fn inner_size(&self) -> Result, CommonCheckErrorKind> { let out = match self { // NoType's may be asked for their size at runtime -- // legal constructions like `(ok 1)` have NoType parts (if they have unknown error variant types). @@ -1392,9 +1396,9 @@ impl TypeSignature { Ok(out) } - pub fn type_size(&self) -> Result { + pub fn type_size(&self) -> Result { self.inner_type_size() - .ok_or_else(|| CheckErrorKind::ValueTooLarge) + .ok_or_else(|| CommonCheckErrorKind::ValueTooLarge) } /// Returns the size of the _type signature_ @@ -1424,7 +1428,7 @@ impl TypeSignature { impl ListTypeData { /// List Size: type_signature_size + max_len * entry_type.size() - fn inner_size(&self) -> Result, CheckErrorKind> { + fn inner_size(&self) -> Result, CommonCheckErrorKind> { let total_size = self .entry_type .size()? @@ -1490,7 +1494,7 @@ impl TupleTypeSignature { /// Tuple Size: /// size( btreemap ) + type_size /// size( btreemap ) = 2*map.len() + sum(names) + sum(values) - fn inner_size(&self) -> Result, CheckErrorKind> { + fn inner_size(&self) -> Result, CommonCheckErrorKind> { let Some(mut total_size) = u32::try_from(self.type_map.len()) .ok() .and_then(|x| x.checked_mul(2)) diff --git a/clarity/src/vm/analysis/analysis_db.rs b/clarity/src/vm/analysis/analysis_db.rs index 62c28813ca0..ff7197249f6 100644 --- a/clarity/src/vm/analysis/analysis_db.rs +++ b/clarity/src/vm/analysis/analysis_db.rs @@ -20,7 +20,7 @@ use clarity_types::representations::ClarityName; use clarity_types::types::{QualifiedContractIdentifier, TraitIdentifier}; use stacks_common::types::StacksEpochId; -use crate::vm::analysis::errors::{CheckErrorKind, StaticCheckError}; +use crate::vm::analysis::errors::{StaticCheckError, StaticCheckErrorKind}; use crate::vm::analysis::type_checker::ContractAnalysis; use crate::vm::database::{ ClarityBackingStore, ClarityDeserializable, ClaritySerializable, RollbackWrapper, @@ -46,16 +46,16 @@ impl<'a> AnalysisDatabase<'a> { pub fn execute(&mut self, f: F) -> Result where F: FnOnce(&mut Self) -> Result, - E: From, + E: From, { self.begin(); let result = f(self).or_else(|e| { self.roll_back() - .map_err(|e| CheckErrorKind::Expects(format!("{e:?}")))?; + .map_err(|e| StaticCheckErrorKind::Expects(format!("{e:?}")))?; Err(e) })?; self.commit() - .map_err(|e| CheckErrorKind::Expects(format!("{e:?}")))?; + .map_err(|e| StaticCheckErrorKind::Expects(format!("{e:?}")))?; Ok(result) } @@ -66,13 +66,13 @@ impl<'a> AnalysisDatabase<'a> { pub fn commit(&mut self) -> Result<(), StaticCheckError> { self.store .commit() - .map_err(|e| CheckErrorKind::Expects(format!("{e:?}")).into()) + .map_err(|e| StaticCheckErrorKind::Expects(format!("{e:?}")).into()) } pub fn roll_back(&mut self) -> Result<(), StaticCheckError> { self.store .rollback() - .map_err(|e| CheckErrorKind::Expects(format!("{e:?}")).into()) + .map_err(|e| StaticCheckErrorKind::Expects(format!("{e:?}")).into()) } pub fn storage_key() -> &'static str { @@ -108,7 +108,7 @@ impl<'a> AnalysisDatabase<'a> { .flatten() .map(|x| { ContractAnalysis::deserialize(&x).map_err(|_| { - CheckErrorKind::Expects("Bad data deserialized from DB".into()).into() + StaticCheckErrorKind::Expects("Bad data deserialized from DB".into()).into() }) }) .transpose() @@ -127,8 +127,9 @@ impl<'a> AnalysisDatabase<'a> { .ok() .flatten() .map(|x| { - ContractAnalysis::deserialize(&x) - .map_err(|_| CheckErrorKind::Expects("Bad data deserialized from DB".into())) + ContractAnalysis::deserialize(&x).map_err(|_| { + StaticCheckErrorKind::Expects("Bad data deserialized from DB".into()) + }) }) .transpose()? .map(|mut x| { @@ -144,14 +145,15 @@ impl<'a> AnalysisDatabase<'a> { ) -> Result<(), StaticCheckError> { let key = AnalysisDatabase::storage_key(); if self.store.has_metadata_entry(contract_identifier, key) { - return Err( - CheckErrorKind::ContractAlreadyExists(contract_identifier.to_string()).into(), - ); + return Err(StaticCheckErrorKind::ContractAlreadyExists( + contract_identifier.to_string(), + ) + .into()); } self.store .insert_metadata(contract_identifier, key, &contract.serialize()) - .map_err(|e| CheckErrorKind::Expects(format!("{e:?}")))?; + .map_err(|e| StaticCheckErrorKind::Expects(format!("{e:?}")))?; Ok(()) } @@ -165,7 +167,7 @@ impl<'a> AnalysisDatabase<'a> { // charges based on the function type size. let contract = self .load_contract_non_canonical(contract_identifier)? - .ok_or(CheckErrorKind::NoSuchContract( + .ok_or(StaticCheckErrorKind::NoSuchContract( contract_identifier.to_string(), ))?; Ok(contract.clarity_version) @@ -183,7 +185,7 @@ impl<'a> AnalysisDatabase<'a> { // charges based on the function type size. let contract = self .load_contract_non_canonical(contract_identifier)? - .ok_or(CheckErrorKind::NoSuchContract( + .ok_or(StaticCheckErrorKind::NoSuchContract( contract_identifier.to_string(), ))?; Ok(contract @@ -203,7 +205,7 @@ impl<'a> AnalysisDatabase<'a> { // charges based on the function type size. let contract = self .load_contract_non_canonical(contract_identifier)? - .ok_or(CheckErrorKind::NoSuchContract( + .ok_or(StaticCheckErrorKind::NoSuchContract( contract_identifier.to_string(), ))?; Ok(contract @@ -223,7 +225,7 @@ impl<'a> AnalysisDatabase<'a> { // charges based on the function type size. let contract = self .load_contract_non_canonical(contract_identifier)? - .ok_or(CheckErrorKind::NoSuchContract( + .ok_or(StaticCheckErrorKind::NoSuchContract( contract_identifier.to_string(), ))?; Ok(contract.get_defined_trait(trait_name).map(|trait_map| { @@ -240,7 +242,7 @@ impl<'a> AnalysisDatabase<'a> { ) -> Result, StaticCheckError> { let contract = self .load_contract_non_canonical(contract_identifier)? - .ok_or(CheckErrorKind::NoSuchContract( + .ok_or(StaticCheckErrorKind::NoSuchContract( contract_identifier.to_string(), ))?; Ok(contract.implemented_traits) diff --git a/clarity/src/vm/analysis/contract_interface_builder/mod.rs b/clarity/src/vm/analysis/contract_interface_builder/mod.rs index 5fc0169c5cb..54f1a161cf7 100644 --- a/clarity/src/vm/analysis/contract_interface_builder/mod.rs +++ b/clarity/src/vm/analysis/contract_interface_builder/mod.rs @@ -19,12 +19,12 @@ use std::collections::{BTreeMap, BTreeSet}; use stacks_common::types::StacksEpochId; use crate::vm::analysis::types::ContractAnalysis; -use crate::vm::analysis::StaticCheckError; +use crate::vm::analysis::{StaticCheckError, StaticCheckErrorKind}; use crate::vm::types::signatures::CallableSubtype; use crate::vm::types::{ FixedFunction, FunctionArg, FunctionType, TupleTypeSignature, TypeSignature, }; -use crate::vm::{CheckErrorKind, ClarityName, ClarityVersion}; +use crate::vm::{ClarityName, ClarityVersion}; pub fn build_contract_interface( contract_analysis: &ContractAnalysis, @@ -278,7 +278,7 @@ impl ContractInterfaceFunction { FunctionType::Fixed(FixedFunction { returns, .. }) => { ContractInterfaceAtomType::from_type_signature(returns) } - _ => return Err(CheckErrorKind::Expects( + _ => return Err(StaticCheckErrorKind::Expects( "Contract functions should only have fixed function return types!" .into(), ) @@ -290,7 +290,7 @@ impl ContractInterfaceFunction { ContractInterfaceFunctionArg::from_function_args(args) } _ => { - return Err(CheckErrorKind::Expects( + return Err(StaticCheckErrorKind::Expects( "Contract functions should only have fixed function arguments!" .into(), ) @@ -402,7 +402,7 @@ impl ContractInterface { pub fn serialize(&self) -> Result { serde_json::to_string(self).map_err(|_| { - CheckErrorKind::Expects("Failed to serialize contract interface".into()).into() + StaticCheckErrorKind::Expects("Failed to serialize contract interface".into()).into() }) } } diff --git a/clarity/src/vm/analysis/errors.rs b/clarity/src/vm/analysis/errors.rs index 7bf7faabc13..c7e326e6a6e 100644 --- a/clarity/src/vm/analysis/errors.rs +++ b/clarity/src/vm/analysis/errors.rs @@ -16,5 +16,5 @@ pub use clarity_types::errors::analysis::{ check_argument_count, check_arguments_at_least, check_arguments_at_most, CheckErrorKind, - StaticCheckError, SyntaxBindingError, SyntaxBindingErrorType, + StaticCheckError, StaticCheckErrorKind, SyntaxBindingError, SyntaxBindingErrorType, }; diff --git a/clarity/src/vm/analysis/mod.rs b/clarity/src/vm/analysis/mod.rs index f25c0d4e732..9da98099d2e 100644 --- a/clarity/src/vm/analysis/mod.rs +++ b/clarity/src/vm/analysis/mod.rs @@ -28,7 +28,7 @@ use stacks_common::types::StacksEpochId; pub use self::analysis_db::AnalysisDatabase; use self::arithmetic_checker::ArithmeticOnlyChecker; use self::contract_interface_builder::build_contract_interface; -pub use self::errors::{CheckErrorKind, StaticCheckError}; +pub use self::errors::{CheckErrorKind, StaticCheckError, StaticCheckErrorKind}; use self::read_only_checker::ReadOnlyChecker; use self::trait_checker::TraitChecker; use self::type_checker::v2_05::TypeChecker as TypeChecker2_05; @@ -54,9 +54,10 @@ pub fn mem_type_check( epoch: StacksEpochId, ) -> Result<(Option, ContractAnalysis), StaticCheckError> { let contract_identifier = QualifiedContractIdentifier::transient(); - let contract = build_ast(&contract_identifier, snippet, &mut (), version, epoch) - .map_err(|_| CheckErrorKind::Expects("Failed to build AST".into()))? - .expressions; + let contract: Vec = + build_ast(&contract_identifier, snippet, &mut (), version, epoch) + .map_err(|_| StaticCheckErrorKind::Expects("Failed to build AST".into()))? + .expressions; let mut marf = MemoryBackingStore::new(); let mut analysis_db = marf.as_analysis_db(); @@ -73,16 +74,15 @@ pub fn mem_type_check( ) { Ok(x) => { // return the first type result of the type checker - let first_type = x - .type_map - .as_ref() - .ok_or_else(|| CheckErrorKind::Expects("Should be non-empty".into()))? - .get_type_expected( - x.expressions - .last() - .ok_or_else(|| CheckErrorKind::Expects("Should be non-empty".into()))?, - ) - .cloned(); + + let first_type = + x.type_map + .as_ref() + .ok_or_else(|| StaticCheckErrorKind::Expects("Should be non-empty".into()))? + .get_type_expected(x.expressions.last().ok_or_else(|| { + StaticCheckErrorKind::Expects("Should be non-empty".into()) + })?) + .cloned(); Ok((first_type, x)) } Err(e) => Err(e.0), @@ -151,7 +151,7 @@ pub fn run_analysis( TypeChecker2_1::run_pass(&epoch, &mut contract_analysis, db, build_type_map) } StacksEpochId::Epoch10 => { - return Err(CheckErrorKind::Expects( + return Err(StaticCheckErrorKind::Expects( "Epoch 1.0 is not a valid epoch for analysis".into(), ) .into()) diff --git a/clarity/src/vm/analysis/read_only_checker/mod.rs b/clarity/src/vm/analysis/read_only_checker/mod.rs index 9faea79fa0e..c41a452cab4 100644 --- a/clarity/src/vm/analysis/read_only_checker/mod.rs +++ b/clarity/src/vm/analysis/read_only_checker/mod.rs @@ -22,7 +22,7 @@ use stacks_common::types::StacksEpochId; pub use super::errors::{ check_argument_count, check_arguments_at_least, CheckErrorKind, StaticCheckError, - SyntaxBindingError, + StaticCheckErrorKind, SyntaxBindingError, }; use super::AnalysisDatabase; use crate::vm::analysis::types::{AnalysisPass, ContractAnalysis}; @@ -82,7 +82,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { /// Returns successfully iff this function is read-only correct. /// /// # Errors - /// - `CheckErrorKind::WriteAttemptedInReadOnly` + /// - `StaticCheckErrorKind::WriteAttemptedInReadOnly` /// - Contract parsing errors pub fn run(&mut self, contract_analysis: &ContractAnalysis) -> Result<(), StaticCheckError> { // Iterate over all the top-level statements in a contract. @@ -106,7 +106,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { /// Returns successfully iff this function is read-only correct. /// /// # Errors - /// - CheckErrorKind::WriteAttemptedInReadOnly + /// - StaticCheckErrorKind::WriteAttemptedInReadOnly /// - Contract parsing errors fn check_top_level_expression( &mut self, @@ -136,7 +136,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { let (function_name, is_read_only) = self.check_define_function(signature, body)?; if !is_read_only { - return Err(CheckErrorKind::WriteAttemptedInReadOnly.into()); + return Err(StaticCheckErrorKind::WriteAttemptedInReadOnly.into()); } else { self.defined_functions.insert(function_name, is_read_only); } @@ -172,9 +172,9 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { ) -> Result<(ClarityName, bool), StaticCheckError> { let function_name = signature .first() - .ok_or(CheckErrorKind::DefineFunctionBadSignature)? + .ok_or(StaticCheckErrorKind::DefineFunctionBadSignature)? .match_atom() - .ok_or(CheckErrorKind::BadFunctionName)?; + .ok_or(StaticCheckErrorKind::BadFunctionName)?; let is_read_only = self.check_read_only(body)?; @@ -207,7 +207,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { ReadOnlyFunction { signature, body } => { let (f_name, is_read_only) = self.check_define_function(signature, body)?; if !is_read_only { - return Err(CheckErrorKind::WriteAttemptedInReadOnly.into()); + return Err(StaticCheckErrorKind::WriteAttemptedInReadOnly.into()); } else { self.defined_functions.insert(f_name, is_read_only); } @@ -314,7 +314,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { let is_block_arg_read_only = self.check_read_only(&args[0])?; let closure_read_only = self.check_read_only(&args[1])?; if !closure_read_only { - return Err(CheckErrorKind::AtBlockClosureMustBeReadOnly.into()); + return Err(StaticCheckErrorKind::AtBlockClosureMustBeReadOnly.into()); } Ok(is_block_arg_read_only) } @@ -331,7 +331,9 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { Let => { check_arguments_at_least(2, args)?; - let binding_list = args[0].match_list().ok_or(CheckErrorKind::BadLetSyntax)?; + let binding_list = args[0] + .match_list() + .ok_or(StaticCheckErrorKind::BadLetSyntax)?; for (i, pair) in binding_list.iter().enumerate() { let pair_expression = pair.match_list().ok_or_else(|| { @@ -406,7 +408,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { let function_name = args[1] .match_atom() - .ok_or(CheckErrorKind::ContractCallExpectName)?; + .ok_or(StaticCheckErrorKind::ContractCallExpectName)?; let is_function_read_only = match &args[0].expr { SymbolicExpressionType::LiteralValue(Value::Principal( @@ -427,7 +429,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { } _ => { return Err(StaticCheckError::new( - CheckErrorKind::ContractCallExpectName, + StaticCheckErrorKind::ContractCallExpectName, )) } }; @@ -454,11 +456,11 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { ) -> Result { let (function_name, args) = expressions .split_first() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; let function_name = function_name .match_atom() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; if let Some(mut result) = self.try_check_native_function_is_read_only(function_name, args) { if let Err(ref mut check_err) = result { @@ -466,10 +468,9 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { } result } else { - let is_function_read_only = *self - .defined_functions - .get(function_name) - .ok_or(CheckErrorKind::UnknownFunction(function_name.to_string()))?; + let is_function_read_only = *self.defined_functions.get(function_name).ok_or( + StaticCheckErrorKind::UnknownFunction(function_name.to_string()), + )?; self.check_each_expression_is_read_only(args) .map(|args_read_only| args_read_only && is_function_read_only) } diff --git a/clarity/src/vm/analysis/read_only_checker/tests.rs b/clarity/src/vm/analysis/read_only_checker/tests.rs index 5b985b7b2f2..9e0f8b46aaa 100644 --- a/clarity/src/vm/analysis/read_only_checker/tests.rs +++ b/clarity/src/vm/analysis/read_only_checker/tests.rs @@ -20,10 +20,11 @@ use rstest::rstest; use rstest_reuse::{self, *}; use stacks_common::types::StacksEpochId; +use crate::vm::analysis::type_check; use crate::vm::analysis::type_checker::v2_1::tests::mem_type_check; -use crate::vm::analysis::{type_check, CheckErrorKind}; use crate::vm::ast::parse; use crate::vm::database::MemoryBackingStore; +use crate::vm::errors::StaticCheckErrorKind; use crate::vm::tests::test_clarity_versions; use crate::vm::types::QualifiedContractIdentifier; use crate::vm::ClarityVersion; @@ -34,11 +35,11 @@ fn test_argument_count_violations() { ( "(define-private (foo-bar) (at-block))", - CheckErrorKind::IncorrectArgumentCount(2, 0), + StaticCheckErrorKind::IncorrectArgumentCount(2, 0), ), ( "(define-private (foo-bar) (map-get?))", - CheckErrorKind::IncorrectArgumentCount(2, 0), + StaticCheckErrorKind::IncorrectArgumentCount(2, 0), ), ]; @@ -72,7 +73,7 @@ fn test_at_block_violations() { for contract in examples.iter() { let err = mem_type_check(contract).unwrap_err(); eprintln!("{err}"); - assert_eq!(*err.err, CheckErrorKind::AtBlockClosureMustBeReadOnly) + assert_eq!(*err.err, StaticCheckErrorKind::AtBlockClosureMustBeReadOnly) } } @@ -163,7 +164,7 @@ fn test_simple_read_only_violations() { for contract in bad_contracts.iter() { let err = mem_type_check(contract).unwrap_err(); - assert_eq!(*err.err, CheckErrorKind::WriteAttemptedInReadOnly) + assert_eq!(*err.err, StaticCheckErrorKind::WriteAttemptedInReadOnly) } } @@ -180,7 +181,7 @@ fn test_nested_writing_closure() { for contract in bad_contracts.iter() { let err = mem_type_check(contract).unwrap_err(); - assert_eq!(*err.err, CheckErrorKind::AtBlockClosureMustBeReadOnly) + assert_eq!(*err.err, StaticCheckErrorKind::AtBlockClosureMustBeReadOnly) } } @@ -231,7 +232,7 @@ fn test_contract_call_read_only_violations( ) }) .unwrap_err(); - assert_eq!(*err.err, CheckErrorKind::WriteAttemptedInReadOnly); + assert_eq!(*err.err, StaticCheckErrorKind::WriteAttemptedInReadOnly); db.execute(|db| { type_check( diff --git a/clarity/src/vm/analysis/trait_checker/mod.rs b/clarity/src/vm/analysis/trait_checker/mod.rs index a2563de2d47..01396a64e25 100644 --- a/clarity/src/vm/analysis/trait_checker/mod.rs +++ b/clarity/src/vm/analysis/trait_checker/mod.rs @@ -15,7 +15,7 @@ // along with this program. If not, see . use stacks_common::types::StacksEpochId; -use crate::vm::analysis::errors::{CheckErrorKind, StaticCheckError}; +use crate::vm::analysis::errors::{StaticCheckError, StaticCheckErrorKind}; use crate::vm::analysis::types::{AnalysisPass, ContractAnalysis}; use crate::vm::analysis::AnalysisDatabase; @@ -49,13 +49,13 @@ impl TraitChecker { let trait_name = trait_identifier.name.to_string(); let contract_defining_trait = analysis_db .load_contract(&trait_identifier.contract_identifier, &self.epoch)? - .ok_or(CheckErrorKind::TraitReferenceUnknown( + .ok_or(StaticCheckErrorKind::TraitReferenceUnknown( trait_identifier.name.to_string(), ))?; let trait_definition = contract_defining_trait .get_defined_trait(&trait_name) - .ok_or(CheckErrorKind::TraitReferenceUnknown( + .ok_or(StaticCheckErrorKind::TraitReferenceUnknown( trait_identifier.name.to_string(), ))?; diff --git a/clarity/src/vm/analysis/trait_checker/tests.rs b/clarity/src/vm/analysis/trait_checker/tests.rs index c103f7a6eaa..a04ad00d8c9 100644 --- a/clarity/src/vm/analysis/trait_checker/tests.rs +++ b/clarity/src/vm/analysis/trait_checker/tests.rs @@ -20,8 +20,7 @@ use rstest::rstest; use rstest_reuse::{self, *}; use stacks_common::types::StacksEpochId; -use crate::vm::analysis::errors::CheckErrorKind; -use crate::vm::analysis::{type_check, StaticCheckError}; +use crate::vm::analysis::{type_check, StaticCheckError, StaticCheckErrorKind}; use crate::vm::ast::errors::ParseErrorKind; use crate::vm::ast::{build_ast, parse}; use crate::vm::database::MemoryBackingStore; @@ -98,7 +97,7 @@ fn test_incomplete_impl_trait_1(#[case] version: ClarityVersion, #[case] epoch: }) .unwrap_err(); match *err.err { - CheckErrorKind::BadTraitImplementation(_, _) => {} + StaticCheckErrorKind::BadTraitImplementation(_, _) => {} _ => panic!("{err:?}"), } } @@ -125,7 +124,7 @@ fn test_incomplete_impl_trait_2(#[case] version: ClarityVersion, #[case] epoch: }) .unwrap_err(); match *err.err { - CheckErrorKind::BadTraitImplementation(_, _) => {} + StaticCheckErrorKind::BadTraitImplementation(_, _) => {} _ => panic!("{err:?}"), } } @@ -149,7 +148,7 @@ fn test_impl_trait_arg_admission_1(#[case] version: ClarityVersion, #[case] epoc }) .unwrap_err(); match *err.err { - CheckErrorKind::BadTraitImplementation(_, _) => {} + StaticCheckErrorKind::BadTraitImplementation(_, _) => {} _ => panic!("{err:?}"), } } @@ -289,7 +288,7 @@ fn test_get_trait_reference_from_tuple( }) .unwrap_err(); match *err.err { - CheckErrorKind::ContractCallExpectName => {} + StaticCheckErrorKind::ContractCallExpectName => {} _ => panic!("{err:?}"), } } @@ -332,7 +331,7 @@ fn test_dynamic_dispatch_by_defining_and_impl_trait( }) .unwrap_err(); match *err.err { - CheckErrorKind::TraitReferenceUnknown(_) => {} + StaticCheckErrorKind::TraitReferenceUnknown(_) => {} _ => panic!("{err:?}"), } } @@ -434,7 +433,7 @@ fn test_cycle_in_traits_2_contracts(#[case] version: ClarityVersion, #[case] epo }) .unwrap_err(); match *err.err { - CheckErrorKind::NoSuchContract(_) => {} + StaticCheckErrorKind::NoSuchContract(_) => {} _ => panic!("{err:?}"), } } @@ -487,7 +486,7 @@ fn test_dynamic_dispatch_unknown_method( }) .unwrap_err(); match *err.err { - CheckErrorKind::TraitMethodUnknown(_, _) => {} + StaticCheckErrorKind::TraitMethodUnknown(_, _) => {} _ => panic!("{err:?}"), } } @@ -812,7 +811,7 @@ fn test_dynamic_dispatch_importing_non_existant_trait( }) .unwrap_err(); match *err.err { - CheckErrorKind::TraitReferenceUnknown(_) => {} + StaticCheckErrorKind::TraitReferenceUnknown(_) => {} _ => panic!("{err:?}"), } } @@ -1099,13 +1098,13 @@ fn test_dynamic_dispatch_including_wrong_nested_trait( .unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, actual) if epoch < StacksEpochId::Epoch21 => { + StaticCheckErrorKind::TypeError(expected, actual) if epoch < StacksEpochId::Epoch21 => { match (&*expected, &*actual) { (TypeSignature::TraitReferenceType(_), TypeSignature::TraitReferenceType(_)) => {} _ => panic!("unexpected TypeSignature: {expected:?} {actual:?}"), } } - CheckErrorKind::TypeError(expected, actual) + StaticCheckErrorKind::TypeError(expected, actual) if epoch >= StacksEpochId::Epoch21 && version < ClarityVersion::Clarity2 => { match (&*expected, &*actual) { @@ -1113,7 +1112,7 @@ fn test_dynamic_dispatch_including_wrong_nested_trait( _ => panic!("unexpected TypeSignature: {expected:?} {actual:?}"), } } - CheckErrorKind::TraitReferenceUnknown(name) => assert_eq!(name.as_str(), "trait-a"), + StaticCheckErrorKind::TraitReferenceUnknown(name) => assert_eq!(name.as_str(), "trait-a"), _ => panic!("{err:?}"), } } @@ -1167,7 +1166,7 @@ fn test_dynamic_dispatch_mismatched_args( }) .unwrap_err(); match *err.err { - CheckErrorKind::TypeError(_, _) => {} + StaticCheckErrorKind::TypeError(_, _) => {} _ => panic!("{err:?}"), } } @@ -1221,7 +1220,7 @@ fn test_dynamic_dispatch_mismatched_returns( }) .unwrap_err(); match *err.err { - CheckErrorKind::BadTraitImplementation(_, _) => {} + StaticCheckErrorKind::BadTraitImplementation(_, _) => {} _ => panic!("{err:?}"), } } @@ -1257,7 +1256,7 @@ fn test_bad_call_with_trait(#[case] version: ClarityVersion, #[case] epoch: Stac }) .unwrap_err(); match *err.err { - CheckErrorKind::TypeError(_, _) => {} + StaticCheckErrorKind::TypeError(_, _) => {} _ => panic!("{err:?}"), } } @@ -1466,7 +1465,7 @@ fn test_dynamic_dispatch_pass_bound_principal_as_trait_in_user_defined_functions match result { Err(err) if version == ClarityVersion::Clarity1 => { match *err.err { - CheckErrorKind::TypeError(_, _) => {} + StaticCheckErrorKind::TypeError(_, _) => {} _ => panic!("{err:?}"), }; } @@ -1560,7 +1559,7 @@ fn test_contract_of_wrong_type(#[case] version: ClarityVersion, #[case] epoch: S }) .unwrap_err(); match *err_principal.err { - CheckErrorKind::TraitReferenceUnknown(_) => {} + StaticCheckErrorKind::TraitReferenceUnknown(_) => {} _ => panic!("{err_principal:?}"), } let err_int = db @@ -1570,7 +1569,7 @@ fn test_contract_of_wrong_type(#[case] version: ClarityVersion, #[case] epoch: S }) .unwrap_err(); match *err_int.err { - CheckErrorKind::TraitReferenceUnknown(_) => {} + StaticCheckErrorKind::TraitReferenceUnknown(_) => {} _ => panic!("{err_int:?}"), } let err_uint = db @@ -1580,7 +1579,7 @@ fn test_contract_of_wrong_type(#[case] version: ClarityVersion, #[case] epoch: S }) .unwrap_err(); match *err_uint.err { - CheckErrorKind::TraitReferenceUnknown(_) => {} + StaticCheckErrorKind::TraitReferenceUnknown(_) => {} _ => panic!("{err_uint:?}"), } let err_bool = db @@ -1590,7 +1589,7 @@ fn test_contract_of_wrong_type(#[case] version: ClarityVersion, #[case] epoch: S }) .unwrap_err(); match *err_bool.err { - CheckErrorKind::TraitReferenceUnknown(_) => {} + StaticCheckErrorKind::TraitReferenceUnknown(_) => {} _ => panic!("{err_bool:?}"), } let err_list = db @@ -1600,7 +1599,7 @@ fn test_contract_of_wrong_type(#[case] version: ClarityVersion, #[case] epoch: S }) .unwrap_err(); match *err_list.err { - CheckErrorKind::TraitReferenceUnknown(_) => {} + StaticCheckErrorKind::TraitReferenceUnknown(_) => {} _ => panic!("{err_list:?}"), } let err_buff = db @@ -1610,7 +1609,7 @@ fn test_contract_of_wrong_type(#[case] version: ClarityVersion, #[case] epoch: S }) .unwrap_err(); match *err_buff.err { - CheckErrorKind::TraitReferenceUnknown(_) => {} + StaticCheckErrorKind::TraitReferenceUnknown(_) => {} _ => panic!("{err_buff:?}"), } let err_tuple = db @@ -1620,7 +1619,7 @@ fn test_contract_of_wrong_type(#[case] version: ClarityVersion, #[case] epoch: S }) .unwrap_err(); match *err_tuple.err { - CheckErrorKind::TraitReferenceUnknown(_) => {} + StaticCheckErrorKind::TraitReferenceUnknown(_) => {} _ => panic!("{err_tuple:?}"), } } @@ -1819,7 +1818,7 @@ fn test_trait_contract_not_found(#[case] version: ClarityVersion, #[case] epoch: ) }) { Err(StaticCheckError { err, .. }) if version < ClarityVersion::Clarity2 => match *err { - CheckErrorKind::NoSuchContract(contract) => { + StaticCheckErrorKind::NoSuchContract(contract) => { assert!(contract.ends_with(".trait-contract")) } _ => panic!("{version}: unexpected NoSuchContract error"), diff --git a/clarity/src/vm/analysis/type_checker/contexts.rs b/clarity/src/vm/analysis/type_checker/contexts.rs index 50f8cd16104..8a350431b35 100644 --- a/clarity/src/vm/analysis/type_checker/contexts.rs +++ b/clarity/src/vm/analysis/type_checker/contexts.rs @@ -18,7 +18,7 @@ use std::collections::{HashMap, HashSet}; use stacks_common::types::StacksEpochId; -use crate::vm::analysis::errors::{CheckErrorKind, StaticCheckError}; +use crate::vm::analysis::errors::{StaticCheckError, StaticCheckErrorKind}; use crate::vm::types::signatures::CallableSubtype; use crate::vm::types::{TraitIdentifier, TypeSignature}; use crate::vm::{ClarityName, ClarityVersion, SymbolicExpression, MAX_CONTEXT_DEPTH}; @@ -69,7 +69,7 @@ impl TypeMap { TypeMapDataType::Map(ref mut map) => { if map.insert(expr.id, type_sig).is_some() { Err(StaticCheckError::new( - CheckErrorKind::TypeAlreadyAnnotatedFailure, + StaticCheckErrorKind::TypeAlreadyAnnotatedFailure, )) } else { Ok(()) @@ -78,7 +78,7 @@ impl TypeMap { TypeMapDataType::Set(ref mut map) => { if !map.insert(expr.id) { Err(StaticCheckError::new( - CheckErrorKind::TypeAlreadyAnnotatedFailure, + StaticCheckErrorKind::TypeAlreadyAnnotatedFailure, )) } else { Ok(()) @@ -110,7 +110,7 @@ impl TypingContext<'_> { pub fn extend(&self) -> Result, StaticCheckError> { if self.depth >= MAX_CONTEXT_DEPTH { Err(StaticCheckError::new( - CheckErrorKind::MaxContextDepthReached, + StaticCheckErrorKind::MaxContextDepthReached, )) } else { Ok(TypingContext { diff --git a/clarity/src/vm/analysis/type_checker/mod.rs b/clarity/src/vm/analysis/type_checker/mod.rs index 7305d63d08e..30db2e931ff 100644 --- a/clarity/src/vm/analysis/type_checker/mod.rs +++ b/clarity/src/vm/analysis/type_checker/mod.rs @@ -20,7 +20,7 @@ pub mod v2_1; use stacks_common::types::StacksEpochId; -use super::errors::{CheckErrorKind, StaticCheckError}; +use super::errors::{StaticCheckError, StaticCheckErrorKind}; pub use super::types::{AnalysisPass, ContractAnalysis}; use super::AnalysisDatabase; use crate::vm::costs::CostTracker; @@ -49,7 +49,7 @@ impl FunctionType { | StacksEpochId::Epoch32 | StacksEpochId::Epoch33 => self.check_args_2_1(accounting, args, clarity_version), StacksEpochId::Epoch10 => { - Err(CheckErrorKind::Expects("Epoch10 is not supported".into()).into()) + Err(StaticCheckErrorKind::Expects("Epoch10 is not supported".into()).into()) } } } @@ -77,7 +77,7 @@ impl FunctionType { self.check_args_by_allowing_trait_cast_2_1(db, clarity_version, func_args) } StacksEpochId::Epoch10 => { - Err(CheckErrorKind::Expects("Epoch10 is not supported".into()).into()) + Err(StaticCheckErrorKind::Expects("Epoch10 is not supported".into()).into()) } } } diff --git a/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs b/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs index 684c7ff872b..ac08536c82b 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs @@ -16,7 +16,7 @@ use std::collections::{BTreeMap, HashMap, HashSet}; -use crate::vm::analysis::errors::{CheckErrorKind, StaticCheckError}; +use crate::vm::analysis::errors::{StaticCheckError, StaticCheckErrorKind}; use crate::vm::analysis::types::ContractAnalysis; use crate::vm::representations::ClarityName; use crate::vm::types::signatures::FunctionSignature; @@ -67,9 +67,9 @@ impl ContractContext { || self.traits.contains_key(name) || self.map_types.contains_key(name) { - Err(StaticCheckError::new(CheckErrorKind::NameAlreadyUsed( - name.to_string(), - ))) + Err(StaticCheckError::new( + StaticCheckErrorKind::NameAlreadyUsed(name.to_string()), + )) } else { Ok(()) } diff --git a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs index da3872048d9..8ccd89410bf 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs @@ -27,7 +27,7 @@ pub use self::natives::{SimpleNativeFunction, TypedNativeFunction}; use super::contexts::{TypeMap, TypingContext}; use super::ContractAnalysis; pub use crate::vm::analysis::errors::{ - check_argument_count, check_arguments_at_least, CheckErrorKind, StaticCheckError, + check_argument_count, check_arguments_at_least, StaticCheckError, StaticCheckErrorKind, SyntaxBindingErrorType, }; use crate::vm::analysis::AnalysisDatabase; @@ -147,7 +147,7 @@ impl FunctionType { for found_type in args.iter() { analysis_typecheck_cost(accounting, expected_type, found_type)?; if !expected_type.admits_type(&StacksEpochId::Epoch2_05, found_type)? { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(found_type.clone()), ) @@ -165,7 +165,7 @@ impl FunctionType { { analysis_typecheck_cost(accounting, expected_type, found_type)?; if !expected_type.admits_type(&StacksEpochId::Epoch2_05, found_type)? { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(found_type.clone()), ) @@ -183,10 +183,11 @@ impl FunctionType { return Ok(return_type.clone()); } } - Err( - CheckErrorKind::UnionTypeError(arg_types.clone(), Box::new(found_type.clone())) - .into(), + Err(StaticCheckErrorKind::UnionTypeError( + arg_types.clone(), + Box::new(found_type.clone()), ) + .into()) } FunctionType::ArithmeticVariadic | FunctionType::ArithmeticBinary @@ -197,14 +198,17 @@ impl FunctionType { if self == &FunctionType::ArithmeticBinary { check_argument_count(2, args)?; } - let (first, rest) = args - .split_first() - .ok_or(CheckErrorKind::RequiresAtLeastArguments(1, args.len()))?; + let (first, rest) = + args.split_first() + .ok_or(StaticCheckErrorKind::RequiresAtLeastArguments( + 1, + args.len(), + ))?; analysis_typecheck_cost(accounting, &TypeSignature::IntType, first)?; let return_type = match first { TypeSignature::IntType => Ok(TypeSignature::IntType), TypeSignature::UIntType => Ok(TypeSignature::UIntType), - _ => Err(CheckErrorKind::UnionTypeError( + _ => Err(StaticCheckErrorKind::UnionTypeError( vec![TypeSignature::IntType, TypeSignature::UIntType], Box::new(first.clone()), )), @@ -212,7 +216,7 @@ impl FunctionType { for found_type in rest.iter() { analysis_typecheck_cost(accounting, &TypeSignature::IntType, found_type)?; if found_type != &return_type { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(return_type), Box::new(found_type.clone()), ) @@ -228,7 +232,7 @@ impl FunctionType { analysis_typecheck_cost(accounting, &TypeSignature::IntType, second)?; if first != &TypeSignature::IntType && first != &TypeSignature::UIntType { - return Err(CheckErrorKind::UnionTypeError( + return Err(StaticCheckErrorKind::UnionTypeError( vec![TypeSignature::IntType, TypeSignature::UIntType], Box::new(first.clone()), ) @@ -236,7 +240,7 @@ impl FunctionType { } if first != second { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(first.clone()), Box::new(second.clone()), ) @@ -245,7 +249,7 @@ impl FunctionType { Ok(TypeSignature::BoolType) } - FunctionType::Binary(_, _, _) => Err(CheckErrorKind::Expects( + FunctionType::Binary(_, _, _) => Err(StaticCheckErrorKind::Expects( "Binary type should not be reached in 2.05".into(), ) .into()), @@ -259,7 +263,9 @@ impl FunctionType { ) -> Result { let (expected_args, returns) = match self { FunctionType::Fixed(FixedFunction { args, returns }) => (args, returns), - _ => return Err(CheckErrorKind::Expects("Unexpected function type".into()).into()), + _ => { + return Err(StaticCheckErrorKind::Expects("Unexpected function type".into()).into()) + } }; check_argument_count(expected_args.len(), func_args)?; @@ -271,7 +277,9 @@ impl FunctionType { ) => { let contract_to_check = db .load_contract(contract, &StacksEpochId::Epoch2_05)? - .ok_or_else(|| CheckErrorKind::NoSuchContract(contract.name.to_string()))?; + .ok_or_else(|| { + StaticCheckErrorKind::NoSuchContract(contract.name.to_string()) + })?; let trait_definition = db .get_defined_trait( &trait_id.contract_identifier, @@ -279,9 +287,11 @@ impl FunctionType { &StacksEpochId::Epoch2_05, ) .map_err(|_| { - CheckErrorKind::NoSuchContract(trait_id.contract_identifier.to_string()) + StaticCheckErrorKind::NoSuchContract( + trait_id.contract_identifier.to_string(), + ) })? - .ok_or(CheckErrorKind::NoSuchContract( + .ok_or(StaticCheckErrorKind::NoSuchContract( trait_id.contract_identifier.to_string(), ))?; contract_to_check.check_trait_compliance( @@ -293,7 +303,7 @@ impl FunctionType { (expected_type, value) => { if !expected_type.admits(&StacksEpochId::Epoch2_05, value)? { let actual_type = TypeSignature::type_of(value)?; - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(actual_type), ) @@ -327,13 +337,13 @@ fn type_reserved_variable(variable_name: &str) -> Result, BlockHeight => TypeSignature::UIntType, BurnBlockHeight => TypeSignature::UIntType, NativeNone => TypeSignature::new_option(no_type()) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, NativeTrue => TypeSignature::BoolType, NativeFalse => TypeSignature::BoolType, TotalLiquidMicroSTX => TypeSignature::UIntType, Regtest => TypeSignature::BoolType, TxSponsor | Mainnet | ChainId | StacksBlockHeight | TenureHeight | StacksBlockTime | CurrentContract => { - return Err(CheckErrorKind::Expects( + return Err(StaticCheckErrorKind::Expects( "tx-sponsor, mainnet, chain-id, stacks-block-height, tenure-height, stacks-block-time, and current-contract should not reach here in 2.05".into(), ) .into()) @@ -393,7 +403,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { &return_type, ) .map_err(|_| { - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( Box::new(expected_type), Box::new(return_type), ) @@ -424,7 +434,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { } Err(e) => Err(e), })? - .ok_or_else(|| CheckErrorKind::Expects("Expected a depth result".into()))?; + .ok_or_else(|| StaticCheckErrorKind::Expects("Expected a depth result".into()))?; } runtime_cost(ClarityCostFunction::AnalysisStorage, self, size)?; @@ -463,7 +473,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { let contract_to_check = self .db .load_contract(contract_identifier, &StacksEpochId::Epoch2_05)? - .ok_or(CheckErrorKind::NoSuchContract( + .ok_or(StaticCheckErrorKind::NoSuchContract( contract_identifier.to_string(), ))?; @@ -473,13 +483,13 @@ impl<'a, 'b> TypeChecker<'a, 'b> { &trait_identifier.contract_identifier, &StacksEpochId::Epoch2_05, )? - .ok_or(CheckErrorKind::NoSuchContract( + .ok_or(StaticCheckErrorKind::NoSuchContract( trait_identifier.contract_identifier.to_string(), ))?; let trait_definition = contract_defining_trait .get_defined_trait(&trait_identifier.name) - .ok_or(CheckErrorKind::NoSuchTrait( + .ok_or(StaticCheckErrorKind::NoSuchTrait( trait_identifier.contract_identifier.to_string(), trait_identifier.name.to_string(), ))?; @@ -496,9 +506,11 @@ impl<'a, 'b> TypeChecker<'a, 'b> { analysis_typecheck_cost(self, expected_type, &actual_type)?; if !expected_type.admits_type(&StacksEpochId::Epoch2_05, &actual_type)? { - let mut err: StaticCheckError = - CheckErrorKind::TypeError(Box::new(expected_type.clone()), Box::new(actual_type)) - .into(); + let mut err: StaticCheckError = StaticCheckErrorKind::TypeError( + Box::new(expected_type.clone()), + Box::new(actual_type), + ) + .into(); err.set_expression(expr); Err(err) } else { @@ -533,12 +545,12 @@ impl<'a, 'b> TypeChecker<'a, 'b> { let mut types_returned = self.type_check_all(args, context)?; let last_return = types_returned.pop().ok_or(StaticCheckError::new( - CheckErrorKind::CheckerImplementationFailure, + StaticCheckErrorKind::CheckerImplementationFailure, ))?; for type_return in types_returned.iter() { if type_return.is_response_type() { - return Err(CheckErrorKind::UncheckedIntermediaryResponses.into()); + return Err(StaticCheckErrorKind::UncheckedIntermediaryResponses.into()); } } Ok(last_return) @@ -581,10 +593,10 @@ impl<'a, 'b> TypeChecker<'a, 'b> { ) -> Result<(ClarityName, FixedFunction), StaticCheckError> { let (function_name, args) = signature .split_first() - .ok_or(CheckErrorKind::RequiresAtLeastArguments(1, 0))?; + .ok_or(StaticCheckErrorKind::RequiresAtLeastArguments(1, 0))?; let function_name = function_name .match_atom() - .ok_or(CheckErrorKind::BadFunctionName)?; + .ok_or(StaticCheckErrorKind::BadFunctionName)?; let args = parse_name_type_pairs::<(), StaticCheckError>( StacksEpochId::Epoch2_05, args, @@ -593,7 +605,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { )?; if self.function_return_tracker.is_some() { - return Err(CheckErrorKind::Expects( + return Err(StaticCheckErrorKind::Expects( "Interpreter error: Previous function define left dirty typecheck state.".into(), ) .into()); @@ -635,7 +647,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { &return_type, ) .map_err(|_| { - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( Box::new(expected.clone()), Box::new(return_type), ) @@ -674,10 +686,10 @@ impl<'a, 'b> TypeChecker<'a, 'b> { // should we set the type of the subexpressions of the signature to no-type as well? let key_type = TypeSignature::parse_type_repr(StacksEpochId::Epoch2_05, key_type, &mut ()) - .map_err(|_| CheckErrorKind::BadMapTypeDefinition)?; + .map_err(|_| StaticCheckErrorKind::BadMapTypeDefinition)?; let value_type = TypeSignature::parse_type_repr(StacksEpochId::Epoch2_05, value_type, &mut ()) - .map_err(|_| CheckErrorKind::BadMapTypeDefinition)?; + .map_err(|_| StaticCheckErrorKind::BadMapTypeDefinition)?; Ok((map_name.clone(), (key_type, value_type))) } @@ -709,19 +721,21 @@ impl<'a, 'b> TypeChecker<'a, 'b> { ) -> Result { let (function_name, args) = expression .split_first() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; self.type_map.set_type(function_name, no_type())?; let function_name = function_name .match_atom() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; if let Some(type_result) = self.try_native_function_check(function_name, args, context) { type_result } else { let function = match self.get_function_type(function_name) { Some(FunctionType::Fixed(function)) => Ok(function), - _ => Err(CheckErrorKind::UnknownFunction(function_name.to_string())), + _ => Err(StaticCheckErrorKind::UnknownFunction( + function_name.to_string(), + )), }?; for (expected_type, found_type) in function.args.iter().map(|x| &x.signature).zip(args) @@ -751,7 +765,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { // be undefined. This early error prevents a cost function error // due to `context.depth` being 0. if context.depth == 0 { - return Err(CheckErrorKind::UndefinedVariable(name.to_string()).into()); + return Err(StaticCheckErrorKind::UndefinedVariable(name.to_string()).into()); } runtime_cost( @@ -763,7 +777,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { if let Some(type_result) = context.lookup_variable_type(name) { Ok(type_result.clone()) } else { - Err(CheckErrorKind::UndefinedVariable(name.to_string()).into()) + Err(StaticCheckErrorKind::UndefinedVariable(name.to_string()).into()) } } } @@ -778,7 +792,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { Atom(ref name) => self.lookup_variable(name, context)?, List(ref expression) => self.type_check_function_application(expression, context)?, TraitReference(_, _) | Field(_) => { - return Err(CheckErrorKind::UnexpectedTraitOrFieldReference.into()); + return Err(StaticCheckErrorKind::UnexpectedTraitOrFieldReference.into()); } }; @@ -810,7 +824,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { ) -> Result<(ClarityName, TypeSignature), StaticCheckError> { let expected_type = TypeSignature::parse_type_repr::<()>(StacksEpochId::Epoch2_05, var_type, &mut ()) - .map_err(|_e| CheckErrorKind::DefineVariableBadSignature)?; + .map_err(|_e| StaticCheckErrorKind::DefineVariableBadSignature)?; self.type_check_expects(initial, context, &expected_type)?; @@ -838,7 +852,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { ) -> Result<(ClarityName, TypeSignature), StaticCheckError> { let asset_type = TypeSignature::parse_type_repr::<()>(StacksEpochId::Epoch2_05, nft_type, &mut ()) - .map_err(|_| CheckErrorKind::DefineNFTBadSignature)?; + .map_err(|_| StaticCheckErrorKind::DefineNFTBadSignature)?; Ok((asset_name.clone(), asset_type)) } @@ -902,9 +916,9 @@ impl<'a, 'b> TypeChecker<'a, 'b> { .add_public_function_type(f_name, FunctionType::Fixed(f_type))?; return Ok(Some(())); } else { - return Err(CheckErrorKind::PublicFunctionMustReturnResponse(Box::new( - f_type.returns, - )) + return Err(StaticCheckErrorKind::PublicFunctionMustReturnResponse( + Box::new(f_type.returns), + ) .into()); } } @@ -1009,9 +1023,10 @@ impl<'a, 'b> TypeChecker<'a, 'b> { None => { // still had to do a db read, even if it didn't exist! runtime_cost(ClarityCostFunction::AnalysisUseTraitEntry, self, 1)?; - return Err( - CheckErrorKind::TraitReferenceUnknown(name.to_string()).into() - ); + return Err(StaticCheckErrorKind::TraitReferenceUnknown( + name.to_string(), + ) + .into()); } } } diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs index 74680694340..3bc0a6af6d1 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs @@ -15,7 +15,9 @@ // along with this program. If not, see . use super::{TypeChecker, TypingContext}; -use crate::vm::analysis::errors::{check_argument_count, CheckErrorKind, StaticCheckError}; +use crate::vm::analysis::errors::{ + check_argument_count, StaticCheckError, StaticCheckErrorKind, +}; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::runtime_cost; use crate::vm::representations::SymbolicExpression; @@ -28,13 +30,15 @@ pub fn check_special_get_owner( ) -> Result { check_argument_count(2, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_asset_type = checker .contract_context .get_nft_type(asset_name) .cloned() - .ok_or_else(|| CheckErrorKind::NoSuchNFT(asset_name.to_string()))?; + .ok_or_else(|| StaticCheckErrorKind::NoSuchNFT(asset_name.to_string()))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -56,10 +60,12 @@ pub fn check_special_get_balance( ) -> Result { check_argument_count(2, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; if !checker.contract_context.ft_exists(asset_name) { - return Err(CheckErrorKind::NoSuchFT(asset_name.to_string()).into()); + return Err(StaticCheckErrorKind::NoSuchFT(asset_name.to_string()).into()); } runtime_cost(ClarityCostFunction::AnalysisTypeLookup, checker, 1)?; @@ -77,13 +83,15 @@ pub fn check_special_mint_asset( ) -> Result { check_argument_count(3, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; let expected_asset_type = checker .contract_context .get_nft_type(asset_name) - .ok_or(CheckErrorKind::NoSuchNFT(asset_name.to_string()))? + .ok_or(StaticCheckErrorKind::NoSuchNFT(asset_name.to_string()))? .clone(); // this clone shouldn't be strictly necessary, but to use `type_check_expects` with this, it would have to be. runtime_cost( @@ -108,7 +116,9 @@ pub fn check_special_mint_token( ) -> Result { check_argument_count(3, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_amount: TypeSignature = TypeSignature::UIntType; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; @@ -119,7 +129,7 @@ pub fn check_special_mint_token( checker.type_check_expects(&args[2], context, &expected_owner_type)?; if !checker.contract_context.ft_exists(asset_name) { - return Err(CheckErrorKind::NoSuchFT(asset_name.to_string()).into()); + return Err(StaticCheckErrorKind::NoSuchFT(asset_name.to_string()).into()); } Ok(TypeSignature::ResponseType(Box::new(( @@ -135,13 +145,15 @@ pub fn check_special_transfer_asset( ) -> Result { check_argument_count(4, args)?; - let token_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let token_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; let expected_asset_type = checker .contract_context .get_nft_type(token_name) - .ok_or(CheckErrorKind::NoSuchNFT(token_name.to_string()))? + .ok_or(StaticCheckErrorKind::NoSuchNFT(token_name.to_string()))? .clone(); runtime_cost( @@ -167,7 +179,9 @@ pub fn check_special_transfer_token( ) -> Result { check_argument_count(4, args)?; - let token_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let token_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_amount: TypeSignature = TypeSignature::UIntType; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; @@ -179,7 +193,7 @@ pub fn check_special_transfer_token( checker.type_check_expects(&args[3], context, &expected_owner_type)?; // recipient if !checker.contract_context.ft_exists(token_name) { - return Err(CheckErrorKind::NoSuchFT(token_name.to_string()).into()); + return Err(StaticCheckErrorKind::NoSuchFT(token_name.to_string()).into()); } Ok(TypeSignature::ResponseType(Box::new(( @@ -195,10 +209,12 @@ pub fn check_special_get_token_supply( ) -> Result { check_argument_count(1, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; if !checker.contract_context.ft_exists(asset_name) { - return Err(CheckErrorKind::NoSuchFT(asset_name.to_string()).into()); + return Err(StaticCheckErrorKind::NoSuchFT(asset_name.to_string()).into()); } runtime_cost(ClarityCostFunction::AnalysisTypeLookup, checker, 1)?; @@ -213,13 +229,15 @@ pub fn check_special_burn_asset( ) -> Result { check_argument_count(3, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; let expected_asset_type = checker .contract_context .get_nft_type(asset_name) - .ok_or(CheckErrorKind::NoSuchNFT(asset_name.to_string()))? + .ok_or(StaticCheckErrorKind::NoSuchNFT(asset_name.to_string()))? .clone(); // this clone shouldn't be strictly necessary, but to use `type_check_expects` with this, it would have to be. runtime_cost( @@ -244,7 +262,9 @@ pub fn check_special_burn_token( ) -> Result { check_argument_count(3, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_amount: TypeSignature = TypeSignature::UIntType; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; @@ -255,7 +275,7 @@ pub fn check_special_burn_token( checker.type_check_expects(&args[2], context, &expected_owner_type)?; if !checker.contract_context.ft_exists(asset_name) { - return Err(CheckErrorKind::NoSuchFT(asset_name.to_string()).into()); + return Err(StaticCheckErrorKind::NoSuchFT(asset_name.to_string()).into()); } Ok(TypeSignature::ResponseType(Box::new(( diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs index e454e424f10..b9cb0122af1 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs @@ -17,7 +17,7 @@ use stacks_common::types::StacksEpochId; use crate::vm::analysis::type_checker::v2_05::{ - check_arguments_at_least, CheckErrorKind, StaticCheckError, TypeChecker, TypingContext, + check_arguments_at_least, StaticCheckError, StaticCheckErrorKind, TypeChecker, TypingContext, }; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, runtime_cost}; @@ -31,14 +31,16 @@ pub fn check_special_fetch_entry( ) -> Result { check_arguments_at_least(2, args)?; - let map_name = args[0].match_atom().ok_or(CheckErrorKind::BadMapName)?; + let map_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadMapName)?; let key_type = checker.type_check(&args[1], context)?; let (expected_key_type, value_type) = checker .contract_context .get_map_type(map_name) - .ok_or(CheckErrorKind::NoSuchMap(map_name.to_string()))?; + .ok_or(StaticCheckErrorKind::NoSuchMap(map_name.to_string()))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -55,7 +57,7 @@ pub fn check_special_fetch_entry( let option_type = TypeSignature::new_option(value_type.clone())?; if !expected_key_type.admits_type(&StacksEpochId::Epoch2_05, &key_type)? { - Err(StaticCheckError::new(CheckErrorKind::TypeError( + Err(StaticCheckError::new(StaticCheckErrorKind::TypeError( Box::new(expected_key_type.clone()), Box::new(key_type), ))) @@ -71,14 +73,16 @@ pub fn check_special_delete_entry( ) -> Result { check_arguments_at_least(2, args)?; - let map_name = args[0].match_atom().ok_or(CheckErrorKind::BadMapName)?; + let map_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadMapName)?; let key_type = checker.type_check(&args[1], context)?; let (expected_key_type, _) = checker .contract_context .get_map_type(map_name) - .ok_or(CheckErrorKind::NoSuchMap(map_name.to_string()))?; + .ok_or(StaticCheckErrorKind::NoSuchMap(map_name.to_string()))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -88,7 +92,7 @@ pub fn check_special_delete_entry( analysis_typecheck_cost(&mut checker.cost_track, expected_key_type, &key_type)?; if !expected_key_type.admits_type(&StacksEpochId::Epoch2_05, &key_type)? { - Err(StaticCheckError::new(CheckErrorKind::TypeError( + Err(StaticCheckError::new(StaticCheckErrorKind::TypeError( Box::new(expected_key_type.clone()), Box::new(key_type), ))) @@ -104,7 +108,9 @@ fn check_set_or_insert_entry( ) -> Result { check_arguments_at_least(3, args)?; - let map_name = args[0].match_atom().ok_or(CheckErrorKind::BadMapName)?; + let map_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadMapName)?; let key_type = checker.type_check(&args[1], context)?; let value_type = checker.type_check(&args[2], context)?; @@ -112,7 +118,7 @@ fn check_set_or_insert_entry( let (expected_key_type, expected_value_type) = checker .contract_context .get_map_type(map_name) - .ok_or(CheckErrorKind::NoSuchMap(map_name.to_string()))?; + .ok_or(StaticCheckErrorKind::NoSuchMap(map_name.to_string()))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -129,12 +135,12 @@ fn check_set_or_insert_entry( analysis_typecheck_cost(&mut checker.cost_track, expected_value_type, &value_type)?; if !expected_key_type.admits_type(&StacksEpochId::Epoch2_05, &key_type)? { - Err(StaticCheckError::new(CheckErrorKind::TypeError( + Err(StaticCheckError::new(StaticCheckErrorKind::TypeError( Box::new(expected_key_type.clone()), Box::new(key_type), ))) } else if !expected_value_type.admits_type(&StacksEpochId::Epoch2_05, &value_type)? { - Err(StaticCheckError::new(CheckErrorKind::TypeError( + Err(StaticCheckError::new(StaticCheckErrorKind::TypeError( Box::new(expected_value_type.clone()), Box::new(value_type), ))) diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs index 4a0b5a65338..6b530c7d098 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs @@ -17,7 +17,7 @@ use stacks_common::types::StacksEpochId; use super::{check_argument_count, check_arguments_at_least, no_type, TypeChecker, TypingContext}; -use crate::vm::analysis::errors::{CheckErrorKind, StaticCheckError, SyntaxBindingErrorType}; +use crate::vm::analysis::errors::{StaticCheckError, StaticCheckErrorKind, SyntaxBindingErrorType}; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, runtime_cost}; use crate::vm::diagnostic::DiagnosableError; @@ -117,10 +117,12 @@ fn inner_handle_tuple_get( let return_type = tuple_type_sig .field_type(field_to_get) - .ok_or(StaticCheckError::new(CheckErrorKind::NoSuchTupleField( - field_to_get.to_string(), - tuple_type_sig.clone(), - )))? + .ok_or(StaticCheckError::new( + StaticCheckErrorKind::NoSuchTupleField( + field_to_get.to_string(), + tuple_type_sig.clone(), + ), + ))? .clone(); Ok(return_type) } @@ -134,7 +136,7 @@ fn check_special_get( let field_to_get = args[0] .match_atom() - .ok_or(CheckErrorKind::BadTupleFieldName)?; + .ok_or(StaticCheckErrorKind::BadTupleFieldName)?; let argument_type = checker.type_check(&args[1], context)?; @@ -146,10 +148,10 @@ fn check_special_get( let option_type = TypeSignature::new_option(inner_type)?; Ok(option_type) } else { - Err(CheckErrorKind::ExpectedTuple(value_type_sig).into()) + Err(StaticCheckErrorKind::ExpectedTuple(value_type_sig).into()) } } else { - Err(CheckErrorKind::ExpectedTuple(Box::new(argument_type)).into()) + Err(StaticCheckErrorKind::ExpectedTuple(Box::new(argument_type)).into()) } } @@ -163,13 +165,13 @@ fn check_special_merge( let res = checker.type_check(&args[0], context)?; let mut base = match res { TypeSignature::TupleType(tuple_sig) => Ok(tuple_sig), - _ => Err(CheckErrorKind::ExpectedTuple(Box::new(res.clone()))), + _ => Err(StaticCheckErrorKind::ExpectedTuple(Box::new(res.clone()))), }?; let res = checker.type_check(&args[1], context)?; let mut update = match res { TypeSignature::TupleType(tuple_sig) => Ok(tuple_sig), - _ => Err(CheckErrorKind::ExpectedTuple(Box::new(res.clone()))), + _ => Err(StaticCheckErrorKind::ExpectedTuple(Box::new(res.clone()))), }?; runtime_cost( ClarityCostFunction::AnalysisCheckTupleMerge, @@ -209,8 +211,9 @@ pub fn check_special_tuple_cons( }, )?; - let tuple_signature = TupleTypeSignature::try_from(tuple_type_data) - .map_err(|e| CheckErrorKind::BadTupleConstruction(e.message()))?; + let tuple_signature = TupleTypeSignature::try_from(tuple_type_data).map_err(|e| { + StaticCheckErrorKind::BadTupleConstruction(StaticCheckErrorKind::from(e).message()) + })?; Ok(TypeSignature::TupleType(tuple_signature)) } @@ -224,7 +227,7 @@ fn check_special_let( let binding_list = args[0] .match_list() - .ok_or(StaticCheckError::new(CheckErrorKind::BadLetSyntax))?; + .ok_or(StaticCheckError::new(StaticCheckErrorKind::BadLetSyntax))?; let mut out_context = context.extend()?; @@ -236,9 +239,9 @@ fn check_special_let( |var_name, var_sexp| { checker.contract_context.check_name_used(var_name)?; if out_context.lookup_variable_type(var_name).is_some() { - return Err(StaticCheckError::new(CheckErrorKind::NameAlreadyUsed( - var_name.to_string(), - ))); + return Err(StaticCheckError::new( + StaticCheckErrorKind::NameAlreadyUsed(var_name.to_string()), + )); } let typed_result = checker.type_check(var_sexp, &out_context)?; @@ -267,14 +270,14 @@ fn check_special_fetch_var( let var_name = args[0] .match_atom() - .ok_or(StaticCheckError::new(CheckErrorKind::BadMapName))?; + .ok_or(StaticCheckError::new(StaticCheckErrorKind::BadMapName))?; let value_type = checker .contract_context .get_persisted_variable_type(var_name) - .ok_or(StaticCheckError::new(CheckErrorKind::NoSuchDataVariable( - var_name.to_string(), - )))?; + .ok_or(StaticCheckError::new( + StaticCheckErrorKind::NoSuchDataVariable(var_name.to_string()), + ))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -292,14 +295,18 @@ fn check_special_set_var( ) -> Result { check_arguments_at_least(2, args)?; - let var_name = args[0].match_atom().ok_or(CheckErrorKind::BadMapName)?; + let var_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadMapName)?; let value_type = checker.type_check(&args[1], context)?; let expected_value_type = checker .contract_context .get_persisted_variable_type(var_name) - .ok_or(CheckErrorKind::NoSuchDataVariable(var_name.to_string()))?; + .ok_or(StaticCheckErrorKind::NoSuchDataVariable( + var_name.to_string(), + ))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -309,7 +316,7 @@ fn check_special_set_var( analysis_typecheck_cost(&mut checker.cost_track, &value_type, expected_value_type)?; if !expected_value_type.admits_type(&StacksEpochId::Epoch2_05, &value_type)? { - Err(StaticCheckError::new(CheckErrorKind::TypeError( + Err(StaticCheckError::new(StaticCheckErrorKind::TypeError( Box::new(expected_value_type.clone()), Box::new(value_type), ))) @@ -331,7 +338,7 @@ fn check_special_equals( for x_type in arg_types.into_iter() { analysis_typecheck_cost(checker, &x_type, &arg_type)?; arg_type = TypeSignature::least_supertype(&StacksEpochId::Epoch2_05, &x_type, &arg_type) - .map_err(|_| CheckErrorKind::TypeError(Box::new(x_type), Box::new(arg_type)))?; + .map_err(|_| StaticCheckErrorKind::TypeError(Box::new(x_type), Box::new(arg_type)))?; } Ok(TypeSignature::BoolType) @@ -354,7 +361,8 @@ fn check_special_if( analysis_typecheck_cost(checker, expr1, expr2)?; TypeSignature::least_supertype(&StacksEpochId::Epoch2_05, expr1, expr2).map_err(|_| { - CheckErrorKind::IfArmsMustMatch(Box::new(expr1.clone()), Box::new(expr2.clone())).into() + StaticCheckErrorKind::IfArmsMustMatch(Box::new(expr1.clone()), Box::new(expr2.clone())) + .into() }) } @@ -366,7 +374,7 @@ fn check_contract_call( check_arguments_at_least(2, args)?; let func_name = args[1].match_atom().ok_or(StaticCheckError::new( - CheckErrorKind::ContractCallExpectName, + StaticCheckErrorKind::ContractCallExpectName, ))?; checker.type_map.set_type(&args[1], no_type())?; @@ -391,10 +399,12 @@ fn check_contract_call( { Ok(function) } else { - Err(StaticCheckError::new(CheckErrorKind::NoSuchPublicFunction( - contract_identifier.to_string(), - func_name.to_string(), - ))) + Err(StaticCheckError::new( + StaticCheckErrorKind::NoSuchPublicFunction( + contract_identifier.to_string(), + func_name.to_string(), + ), + )) } }?; @@ -413,21 +423,22 @@ fn check_contract_call( let trait_id = match context.lookup_trait_reference_type(trait_instance) { Some(trait_id) => trait_id, _ => { - return Err( - CheckErrorKind::TraitReferenceUnknown(trait_instance.to_string()).into(), - ); + return Err(StaticCheckErrorKind::TraitReferenceUnknown( + trait_instance.to_string(), + ) + .into()); } }; runtime_cost(ClarityCostFunction::AnalysisLookupFunction, checker, 0)?; let trait_signature = checker.contract_context.get_trait(&trait_id.name).ok_or( - CheckErrorKind::TraitReferenceUnknown(trait_id.name.to_string()), + StaticCheckErrorKind::TraitReferenceUnknown(trait_id.name.to_string()), )?; let func_signature = trait_signature .get(func_name) - .ok_or(CheckErrorKind::TraitMethodUnknown( + .ok_or(StaticCheckErrorKind::TraitMethodUnknown( trait_id.name.to_string(), func_name.to_string(), ))?; @@ -442,7 +453,7 @@ fn check_contract_call( } _ => { return Err(StaticCheckError::new( - CheckErrorKind::ContractCallExpectName, + StaticCheckErrorKind::ContractCallExpectName, )) } }; @@ -466,14 +477,18 @@ fn check_contract_of( SymbolicExpressionType::Atom(trait_instance) => trait_instance, _ => { return Err(StaticCheckError::new( - CheckErrorKind::ContractOfExpectsTrait, + StaticCheckErrorKind::ContractOfExpectsTrait, )) } }; let trait_id = match context.lookup_trait_reference_type(trait_instance) { Some(trait_id) => trait_id, - _ => return Err(CheckErrorKind::TraitReferenceUnknown(trait_instance.to_string()).into()), + _ => { + return Err( + StaticCheckErrorKind::TraitReferenceUnknown(trait_instance.to_string()).into(), + ) + } }; runtime_cost(ClarityCostFunction::ContractOf, checker, 1)?; @@ -481,7 +496,7 @@ fn check_contract_of( checker .contract_context .get_trait(&trait_id.name) - .ok_or_else(|| CheckErrorKind::TraitReferenceUnknown(trait_id.name.to_string()))?; + .ok_or_else(|| StaticCheckErrorKind::TraitReferenceUnknown(trait_id.name.to_string()))?; Ok(TypeSignature::PrincipalType) } @@ -495,7 +510,7 @@ fn check_principal_of( checker.type_check_expects(&args[0], context, &TypeSignature::BUFFER_33)?; Ok( TypeSignature::new_response(TypeSignature::PrincipalType, TypeSignature::UIntType) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, ) } @@ -509,7 +524,7 @@ fn check_secp256k1_recover( checker.type_check_expects(&args[1], context, &TypeSignature::BUFFER_65)?; Ok( TypeSignature::new_response(TypeSignature::BUFFER_33, TypeSignature::UIntType) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, ) } @@ -533,7 +548,7 @@ fn check_get_block_info( check_arguments_at_least(2, args)?; let block_info_prop_str = args[0].match_atom().ok_or(StaticCheckError::new( - CheckErrorKind::GetBlockInfoExpectPropertyName, + StaticCheckErrorKind::GetBlockInfoExpectPropertyName, ))?; let block_info_prop = BlockInfoProperty::lookup_by_name_at_version( @@ -541,7 +556,7 @@ fn check_get_block_info( &ClarityVersion::Clarity1, ) .ok_or(StaticCheckError::new( - CheckErrorKind::NoSuchBlockInfoProperty(block_info_prop_str.to_string()), + StaticCheckErrorKind::NoSuchBlockInfoProperty(block_info_prop_str.to_string()), ))?; checker.type_check_expects(&args[1], context, &TypeSignature::UIntType)?; @@ -567,7 +582,7 @@ impl TypedNativeFunction { pub fn type_native_function( function: &NativeFunctions, - ) -> Result { + ) -> Result { use self::TypedNativeFunction::{Simple, Special}; use crate::vm::functions::NativeFunctions::*; let out = match function { @@ -589,7 +604,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::IntType, ClarityName::try_from("value".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -600,7 +615,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::UIntType, ClarityName::try_from("value".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -611,7 +626,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::BoolType, ClarityName::try_from("value".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -664,7 +679,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::PrincipalType, ClarityName::try_from("owner".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -676,7 +691,7 @@ impl TypedNativeFunction { FunctionArg::new( TypeSignature::UIntType, ClarityName::try_from("amount".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -684,7 +699,7 @@ impl TypedNativeFunction { FunctionArg::new( TypeSignature::PrincipalType, ClarityName::try_from("sender".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -692,7 +707,7 @@ impl TypedNativeFunction { FunctionArg::new( TypeSignature::PrincipalType, ClarityName::try_from("recipient".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -702,14 +717,14 @@ impl TypedNativeFunction { TypeSignature::BoolType, TypeSignature::UIntType, ) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, }))), StxBurn => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction { args: vec![ FunctionArg::new( TypeSignature::UIntType, ClarityName::try_from("amount".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -717,7 +732,7 @@ impl TypedNativeFunction { FunctionArg::new( TypeSignature::PrincipalType, ClarityName::try_from("sender".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -727,7 +742,7 @@ impl TypedNativeFunction { TypeSignature::BoolType, TypeSignature::UIntType, ) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, }))), GetTokenBalance => Special(SpecialNativeFunction(&assets::check_special_get_balance)), GetAssetOwner => Special(SpecialNativeFunction(&assets::check_special_get_owner)), @@ -793,7 +808,7 @@ impl TypedNativeFunction { | StxGetAccount | BitwiseAnd | BitwiseOr | BitwiseNot | BitwiseLShift | BitwiseRShift | BitwiseXor2 | Slice | ToConsensusBuff | FromConsensusBuff | ReplaceAt | GetStacksBlockInfo | GetTenureInfo | ContractHash | ToAscii => { - return Err(CheckErrorKind::Expects( + return Err(StaticCheckErrorKind::Expects( "Clarity 2+ keywords should not show up in 2.05".into(), )); } diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs index 73a4d87f649..75c931428c3 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs @@ -19,8 +19,8 @@ use clarity_types::types::TypeSignature; use stacks_common::types::StacksEpochId; use crate::vm::analysis::type_checker::v2_05::{ - check_argument_count, check_arguments_at_least, no_type, CheckErrorKind, StaticCheckError, - TypeChecker, TypingContext, + check_argument_count, check_arguments_at_least, no_type, StaticCheckError, + StaticCheckErrorKind, TypeChecker, TypingContext, }; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, runtime_cost}; @@ -82,7 +82,7 @@ pub fn check_special_is_response( if let TypeSignature::ResponseType(_types) = input { Ok(TypeSignature::BoolType) } else { - Err(CheckErrorKind::ExpectedResponseType(Box::new(input)).into()) + Err(StaticCheckErrorKind::ExpectedResponseType(Box::new(input)).into()) } } @@ -100,7 +100,7 @@ pub fn check_special_is_optional( if let TypeSignature::OptionalType(_type) = input { Ok(TypeSignature::BoolType) } else { - Err(CheckErrorKind::ExpectedOptionalType(Box::new(input)).into()) + Err(StaticCheckErrorKind::ExpectedOptionalType(Box::new(input)).into()) } } @@ -120,11 +120,14 @@ pub fn check_special_default_to( let contained_type = *input_type; TypeSignature::least_supertype(&StacksEpochId::Epoch2_05, &default, &contained_type) .map_err(|_| { - CheckErrorKind::DefaultTypesMustMatch(Box::new(default), Box::new(contained_type)) - .into() + StaticCheckErrorKind::DefaultTypesMustMatch( + Box::new(default), + Box::new(contained_type), + ) + .into() }) } else { - Err(CheckErrorKind::ExpectedOptionalType(Box::new(input)).into()) + Err(StaticCheckErrorKind::ExpectedOptionalType(Box::new(input)).into()) } } @@ -152,7 +155,7 @@ fn inner_unwrap( match input { TypeSignature::OptionalType(input_type) => { if input_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseOkType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseOkType.into()) } else { Ok(*input_type) } @@ -160,12 +163,12 @@ fn inner_unwrap( TypeSignature::ResponseType(response_type) => { let ok_type = response_type.0; if ok_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseOkType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseOkType.into()) } else { Ok(ok_type) } } - _ => Err(CheckErrorKind::ExpectedOptionalOrResponseType(Box::new(input)).into()), + _ => Err(StaticCheckErrorKind::ExpectedOptionalOrResponseType(Box::new(input)).into()), } } @@ -178,12 +181,12 @@ fn inner_unwrap_err( if let TypeSignature::ResponseType(response_type) = input { let err_type = response_type.1; if err_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseErrType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseErrType.into()) } else { Ok(err_type) } } else { - Err(CheckErrorKind::ExpectedResponseType(Box::new(input)).into()) + Err(StaticCheckErrorKind::ExpectedResponseType(Box::new(input)).into()) } } @@ -231,7 +234,7 @@ pub fn check_special_try_ret( match input { TypeSignature::OptionalType(input_type) => { if input_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseOkType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseOkType.into()) } else { checker.track_return_type(TypeSignature::new_option(TypeSignature::NoType)?)?; Ok(*input_type) @@ -240,9 +243,9 @@ pub fn check_special_try_ret( TypeSignature::ResponseType(response_type) => { let (ok_type, err_type) = *response_type; if ok_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseOkType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseOkType.into()) } else if err_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseErrType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseErrType.into()) } else { checker.track_return_type(TypeSignature::new_response( TypeSignature::NoType, @@ -251,7 +254,7 @@ pub fn check_special_try_ret( Ok(ok_type) } } - _ => Err(CheckErrorKind::ExpectedOptionalOrResponseType(Box::new(input)).into()), + _ => Err(StaticCheckErrorKind::ExpectedOptionalOrResponseType(Box::new(input)).into()), } } @@ -297,7 +300,7 @@ fn eval_with_new_binding( checker.contract_context.check_name_used(&bind_name)?; if inner_context.lookup_variable_type(&bind_name).is_some() { - return Err(CheckErrorKind::NameAlreadyUsed(bind_name.into()).into()); + return Err(StaticCheckErrorKind::NameAlreadyUsed(bind_name.into()).into()); } inner_context.variable_types.insert(bind_name, bind_type); @@ -312,22 +315,22 @@ fn check_special_match_opt( context: &TypingContext, ) -> Result { if args.len() != 3 { - Err(CheckErrorKind::BadMatchOptionSyntax(Box::new( - CheckErrorKind::IncorrectArgumentCount(4, args.len() + 1), + Err(StaticCheckErrorKind::BadMatchOptionSyntax(Box::new( + StaticCheckErrorKind::IncorrectArgumentCount(4, args.len() + 1), )))?; } let bind_name = args[0] .match_atom() .ok_or_else(|| { - CheckErrorKind::BadMatchOptionSyntax(Box::new(CheckErrorKind::ExpectedName)) + StaticCheckErrorKind::BadMatchOptionSyntax(Box::new(StaticCheckErrorKind::ExpectedName)) })? .clone(); let some_branch = &args[1]; let none_branch = &args[2]; if option_type.is_no_type() { - return Err(CheckErrorKind::CouldNotDetermineMatchTypes.into()); + return Err(StaticCheckErrorKind::CouldNotDetermineMatchTypes.into()); } let some_branch_type = @@ -342,8 +345,11 @@ fn check_special_match_opt( &none_branch_type, ) .map_err(|_| { - CheckErrorKind::MatchArmsMustMatch(Box::new(some_branch_type), Box::new(none_branch_type)) - .into() + StaticCheckErrorKind::MatchArmsMustMatch( + Box::new(some_branch_type), + Box::new(none_branch_type), + ) + .into() }) } @@ -354,22 +360,26 @@ fn check_special_match_resp( context: &TypingContext, ) -> Result { if args.len() != 4 { - Err(CheckErrorKind::BadMatchResponseSyntax(Box::new( - CheckErrorKind::IncorrectArgumentCount(5, args.len() + 1), + Err(StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::IncorrectArgumentCount(5, args.len() + 1), )))?; } let ok_bind_name = args[0] .match_atom() .ok_or_else(|| { - CheckErrorKind::BadMatchResponseSyntax(Box::new(CheckErrorKind::ExpectedName)) + StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::ExpectedName, + )) })? .clone(); let ok_branch = &args[1]; let err_bind_name = args[2] .match_atom() .ok_or_else(|| { - CheckErrorKind::BadMatchResponseSyntax(Box::new(CheckErrorKind::ExpectedName)) + StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::ExpectedName, + )) })? .clone(); let err_branch = &args[3]; @@ -377,7 +387,7 @@ fn check_special_match_resp( let (ok_type, err_type) = resp_type; if ok_type.is_no_type() || err_type.is_no_type() { - return Err(CheckErrorKind::CouldNotDetermineMatchTypes.into()); + return Err(StaticCheckErrorKind::CouldNotDetermineMatchTypes.into()); } let ok_branch_type = eval_with_new_binding(ok_branch, ok_bind_name, ok_type, checker, context)?; @@ -388,8 +398,11 @@ fn check_special_match_resp( TypeSignature::least_supertype(&StacksEpochId::Epoch2_05, &ok_branch_type, &err_branch_type) .map_err(|_| { - CheckErrorKind::MatchArmsMustMatch(Box::new(ok_branch_type), Box::new(err_branch_type)) - .into() + StaticCheckErrorKind::MatchArmsMustMatch( + Box::new(ok_branch_type), + Box::new(err_branch_type), + ) + .into() }) } @@ -409,6 +422,6 @@ pub fn check_special_match( TypeSignature::ResponseType(resp_type) => { check_special_match_resp(*resp_type, checker, &args[1..], context) } - _ => Err(CheckErrorKind::BadMatchInput(Box::new(input)).into()), + _ => Err(StaticCheckErrorKind::BadMatchInput(Box::new(input)).into()), } } diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs index 8b03807c7a9..37f3d83b837 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs @@ -18,8 +18,8 @@ use stacks_common::types::StacksEpochId; use super::{SimpleNativeFunction, TypedNativeFunction}; use crate::vm::analysis::type_checker::v2_05::{ - check_argument_count, check_arguments_at_least, CheckErrorKind, StaticCheckError, TypeChecker, - TypingContext, + check_argument_count, check_arguments_at_least, StaticCheckError, StaticCheckErrorKind, + TypeChecker, TypingContext, }; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, runtime_cost}; @@ -44,14 +44,15 @@ fn get_simple_native_or_user_define( { Ok(function_type) } else { - Err( - CheckErrorKind::IllegalOrUnknownFunctionApplication(function_name.to_string()) - .into(), + Err(StaticCheckErrorKind::IllegalOrUnknownFunctionApplication( + function_name.to_string(), ) + .into()) } } else { checker.get_function_type(function_name).ok_or( - CheckErrorKind::IllegalOrUnknownFunctionApplication(function_name.to_string()).into(), + StaticCheckErrorKind::IllegalOrUnknownFunctionApplication(function_name.to_string()) + .into(), ) } } @@ -65,7 +66,7 @@ pub fn check_special_map( let function_name = args[0] .match_atom() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; // we will only lookup native or defined functions here. // you _cannot_ map a special function. let function_type = get_simple_native_or_user_define(function_name, checker)?; @@ -101,7 +102,7 @@ pub fn check_special_map( // However that could lead to confusions when combining certain types: // ex: (map concat (list "hello " "hi ") "world") would fail, because // strings are handled as sequences. - return Err(CheckErrorKind::ExpectedSequence(Box::new(argument_type)).into()); + return Err(StaticCheckErrorKind::ExpectedSequence(Box::new(argument_type)).into()); } }; func_args.push(entry_type); @@ -110,7 +111,7 @@ pub fn check_special_map( let mapped_type = function_type.check_args(checker, &func_args, context.epoch, context.clarity_version)?; TypeSignature::list_of(mapped_type, min_args) - .map_err(|_| CheckErrorKind::ConstructedListTooLarge.into()) + .map_err(|_| StaticCheckErrorKind::ConstructedListTooLarge.into()) } pub fn check_special_filter( @@ -122,7 +123,7 @@ pub fn check_special_filter( let function_name = args[0] .match_atom() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; // we will only lookup native or defined functions here. // you _cannot_ map a special function. let function_type = get_simple_native_or_user_define(function_name, checker)?; @@ -133,7 +134,7 @@ pub fn check_special_filter( { let input_type = match argument_type { TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new( + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new( argument_type.clone(), ))), }?; @@ -146,7 +147,7 @@ pub fn check_special_filter( )?; if TypeSignature::BoolType != filter_type { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BoolType), Box::new(filter_type), ) @@ -166,7 +167,7 @@ pub fn check_special_fold( let function_name = args[0] .match_atom() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; // we will only lookup native or defined functions here. // you _cannot_ fold a special function. let function_type = get_simple_native_or_user_define(function_name, checker)?; @@ -176,7 +177,9 @@ pub fn check_special_fold( let input_type = match argument_type { TypeSignature::SequenceType(sequence_type) => Ok(sequence_type.unit_type()), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new(argument_type))), + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new( + argument_type, + ))), }?; let initial_value_type = checker.type_check(&args[2], context)?; @@ -234,29 +237,29 @@ pub fn check_special_concat( )?; let new_len = lhs_max_len .checked_add(rhs_max_len) - .ok_or(CheckErrorKind::MaxLengthOverflow)?; + .ok_or(StaticCheckErrorKind::MaxLengthOverflow)?; TypeSignature::list_of(list_entry_type, new_len)? } (BufferType(lhs_len), BufferType(rhs_len)) => { let size: u32 = u32::from(lhs_len) .checked_add(u32::from(rhs_len)) - .ok_or(CheckErrorKind::MaxLengthOverflow)?; + .ok_or(StaticCheckErrorKind::MaxLengthOverflow)?; TypeSignature::SequenceType(BufferType(size.try_into()?)) } (StringType(ASCII(lhs_len)), StringType(ASCII(rhs_len))) => { let size: u32 = u32::from(lhs_len) .checked_add(u32::from(rhs_len)) - .ok_or(CheckErrorKind::MaxLengthOverflow)?; + .ok_or(StaticCheckErrorKind::MaxLengthOverflow)?; TypeSignature::SequenceType(StringType(ASCII(size.try_into()?))) } (StringType(UTF8(lhs_len)), StringType(UTF8(rhs_len))) => { let size: u32 = u32::from(lhs_len) .checked_add(u32::from(rhs_len)) - .ok_or(CheckErrorKind::MaxLengthOverflow)?; + .ok_or(StaticCheckErrorKind::MaxLengthOverflow)?; TypeSignature::SequenceType(StringType(UTF8(size.try_into()?))) } (_, _) => { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(lhs_type.clone()), Box::new(rhs_type.clone()), ) @@ -264,7 +267,7 @@ pub fn check_special_concat( } } } - _ => return Err(CheckErrorKind::ExpectedSequence(Box::new(lhs_type.clone())).into()), + _ => return Err(StaticCheckErrorKind::ExpectedSequence(Box::new(lhs_type.clone())).into()), }; Ok(res) } @@ -293,11 +296,11 @@ pub fn check_special_append( )?; let new_len = lhs_max_len .checked_add(1) - .ok_or(CheckErrorKind::MaxLengthOverflow)?; + .ok_or(StaticCheckErrorKind::MaxLengthOverflow)?; let return_type = TypeSignature::list_of(list_entry_type, new_len)?; Ok(return_type) } - _ => Err(CheckErrorKind::ExpectedListApplication.into()), + _ => Err(StaticCheckErrorKind::ExpectedListApplication.into()), } } @@ -312,7 +315,7 @@ pub fn check_special_as_max_len( SymbolicExpressionType::LiteralValue(Value::UInt(expected_len)) => expected_len, _ => { let expected_len_type = checker.type_check(&args[1], context)?; - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(expected_len_type), ) @@ -329,7 +332,7 @@ pub fn check_special_as_max_len( .set_type(&args[1], TypeSignature::UIntType)?; let expected_len = - u32::try_from(expected_len).map_err(|_e| CheckErrorKind::MaxLengthOverflow)?; + u32::try_from(expected_len).map_err(|_e| StaticCheckErrorKind::MaxLengthOverflow)?; let sequence = checker.type_check(&args[0], context)?; runtime_cost(ClarityCostFunction::AnalysisIterableFunc, checker, 0)?; @@ -355,7 +358,7 @@ pub fn check_special_as_max_len( StringUTF8Length::try_from(expected_len)?, )))), )), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new(sequence)).into()), + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new(sequence)).into()), } } @@ -371,7 +374,9 @@ pub fn check_special_len( match collection_type { TypeSignature::SequenceType(_) => Ok(()), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new(collection_type))), + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new( + collection_type, + ))), }?; Ok(TypeSignature::UIntType) @@ -400,16 +405,16 @@ pub fn check_special_element_at( TypeSignature::SequenceType(StringType(ASCII(_))) => Ok(TypeSignature::OptionalType( Box::new(TypeSignature::SequenceType(StringType(ASCII( BufferLength::try_from(1u32) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, )))), )), TypeSignature::SequenceType(StringType(UTF8(_))) => Ok(TypeSignature::OptionalType( Box::new(TypeSignature::SequenceType(StringType(UTF8( StringUTF8Length::try_from(1u32) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, )))), )), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new(collection_type)).into()), + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new(collection_type)).into()), } } @@ -425,7 +430,7 @@ pub fn check_special_index_of( let expected_input_type = match list_type { TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new(list_type))), + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new(list_type))), }?; checker.type_check_expects(&args[1], context, &expected_input_type)?; diff --git a/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs b/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs index 39e52b274d2..22272d7e435 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs @@ -16,7 +16,7 @@ use stacks_common::types::StacksEpochId; -use crate::vm::analysis::errors::CheckErrorKind; +use crate::vm::analysis::errors::StaticCheckErrorKind; use crate::vm::ast::parse; use crate::vm::database::MemoryBackingStore; use crate::vm::tooling::mem_type_check; @@ -193,108 +193,108 @@ fn test_bad_asset_usage() { ]; let expected = [ - CheckErrorKind::NoSuchFT("stackoos".to_string()), - CheckErrorKind::BadTokenName, - CheckErrorKind::BadTokenName, - CheckErrorKind::TypeError( + StaticCheckErrorKind::NoSuchFT("stackoos".to_string()), + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::IntType), ), - CheckErrorKind::BadTokenName, - CheckErrorKind::NoSuchNFT("stackoos".to_string()), - CheckErrorKind::TypeError( + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::NoSuchNFT("stackoos".to_string()), + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(string_ascii_type(15)), ), - CheckErrorKind::BadTokenName, - CheckErrorKind::NoSuchNFT("stackoos".to_string()), - CheckErrorKind::TypeError( + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::NoSuchNFT("stackoos".to_string()), + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(string_ascii_type(15)), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::NoSuchFT("stackoos".to_string()), - CheckErrorKind::BadTokenName, - CheckErrorKind::TypeError( + StaticCheckErrorKind::NoSuchFT("stackoos".to_string()), + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::BoolType), ), - CheckErrorKind::BadTokenName, - CheckErrorKind::NoSuchNFT("stackoos".to_string()), - CheckErrorKind::TypeError( + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::NoSuchNFT("stackoos".to_string()), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::BadTokenName, - CheckErrorKind::TypeError( + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::NoSuchFT("stackoos".to_string()), - CheckErrorKind::BadTokenName, - CheckErrorKind::TypeError( + StaticCheckErrorKind::NoSuchFT("stackoos".to_string()), + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::BoolType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::BoolType), ), - CheckErrorKind::DefineNFTBadSignature, - CheckErrorKind::TypeError( + StaticCheckErrorKind::DefineNFTBadSignature, + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::IntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::IntType), ), - CheckErrorKind::NoSuchFT("stackoos".to_string()), - CheckErrorKind::NoSuchFT("stackoos".to_string()), - CheckErrorKind::TypeError( + StaticCheckErrorKind::NoSuchFT("stackoos".to_string()), + StaticCheckErrorKind::NoSuchFT("stackoos".to_string()), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::IntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::IntType), ), diff --git a/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs b/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs index 6b6c5137276..3ff400d42ee 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs @@ -19,10 +19,10 @@ use stacks_common::types::StacksEpochId; use {assert_json_diff, serde_json}; use crate::vm::analysis::contract_interface_builder::build_contract_interface; -use crate::vm::analysis::errors::CheckErrorKind; use crate::vm::analysis::{mem_type_check, type_check}; use crate::vm::ast::parse; use crate::vm::database::MemoryBackingStore; +use crate::vm::errors::StaticCheckErrorKind; use crate::vm::types::QualifiedContractIdentifier; use crate::vm::ClarityVersion; @@ -492,7 +492,7 @@ fn test_names_tokens_contracts_bad() { ) }) .unwrap_err(); - assert!(matches!(*err.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*err.err, StaticCheckErrorKind::TypeError(_, _))); } #[test] @@ -534,7 +534,7 @@ fn test_bad_map_usage() { for contract in tests.iter() { let err = mem_type_check(contract, ClarityVersion::Clarity1, StacksEpochId::Epoch2_05) .unwrap_err(); - assert!(matches!(*err.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*err.err, StaticCheckErrorKind::TypeError(_, _))); } assert!(matches!( @@ -545,7 +545,7 @@ fn test_bad_map_usage() { ) .unwrap_err() .err, - CheckErrorKind::UnionTypeError(_, _) + StaticCheckErrorKind::UnionTypeError(_, _) )); } @@ -665,7 +665,7 @@ fn test_expects() { eprintln!("unmatched_return_types returned check error: {err}"); assert!(matches!( *err.err, - CheckErrorKind::ReturnTypesMustMatch(_, _) + StaticCheckErrorKind::ReturnTypesMustMatch(_, _) )); } @@ -678,7 +678,7 @@ fn test_expects() { eprintln!("bad_default_types returned check error: {err}"); assert!(matches!( *err.err, - CheckErrorKind::DefaultTypesMustMatch(_, _) + StaticCheckErrorKind::DefaultTypesMustMatch(_, _) )); let err = mem_type_check( @@ -690,7 +690,7 @@ fn test_expects() { eprintln!("notype_response_type returned check error: {err}"); assert!(matches!( *err.err, - CheckErrorKind::CouldNotDetermineResponseErrType + StaticCheckErrorKind::CouldNotDetermineResponseErrType )); let err = mem_type_check( @@ -702,6 +702,6 @@ fn test_expects() { eprintln!("notype_response_type_2 returned check error: {err}"); assert!(matches!( *err.err, - CheckErrorKind::CouldNotDetermineResponseOkType + StaticCheckErrorKind::CouldNotDetermineResponseOkType )); } diff --git a/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs index db7cdf7810f..6a130dd6537 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs @@ -16,7 +16,7 @@ use stacks_common::types::StacksEpochId; -use crate::vm::analysis::errors::{CheckErrorKind, StaticCheckError, SyntaxBindingError}; +use crate::vm::analysis::errors::{StaticCheckError, StaticCheckErrorKind, SyntaxBindingError}; use crate::vm::analysis::mem_type_check; use crate::vm::ast::build_ast; use crate::vm::ast::errors::ParseErrorKind; @@ -69,10 +69,10 @@ fn test_get_block_info() { "(get-block-info? time)", ]; let bad_expected = [ - CheckErrorKind::NoSuchBlockInfoProperty("none".to_string()), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::RequiresAtLeastArguments(2, 1), + StaticCheckErrorKind::NoSuchBlockInfoProperty("none".to_string()), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::RequiresAtLeastArguments(2, 1), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -113,10 +113,10 @@ fn test_define_trait() { "(define-trait)", ]; let bad_expected = [ - CheckErrorKind::InvalidTypeDescription, - CheckErrorKind::DefineTraitBadSignature, - CheckErrorKind::DefineTraitBadSignature, - CheckErrorKind::InvalidTypeDescription, + StaticCheckErrorKind::InvalidTypeDescription, + StaticCheckErrorKind::DefineTraitBadSignature, + StaticCheckErrorKind::DefineTraitBadSignature, + StaticCheckErrorKind::InvalidTypeDescription, ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { @@ -216,16 +216,16 @@ fn test_stx_ops() { "(stx-get-balance 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR)" ]; let bad_expected = [ - CheckErrorKind::IncorrectArgumentCount(3, 2), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(UIntType)), - CheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), - CheckErrorKind::IncorrectArgumentCount(2, 3), - CheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), - CheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(UIntType)), + StaticCheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -291,7 +291,7 @@ fn test_destructuring_opts() { let bad = [ ( "(unwrap-err! (some 2) 2)", - CheckErrorKind::ExpectedResponseType(Box::new(TypeSignature::from_string( + StaticCheckErrorKind::ExpectedResponseType(Box::new(TypeSignature::from_string( "(optional int)", ClarityVersion::Clarity1, StacksEpochId::Epoch2_05, @@ -299,90 +299,99 @@ fn test_destructuring_opts() { ), ( "(unwrap! (err 3) 2)", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(unwrap-err-panic (ok 3))", - CheckErrorKind::CouldNotDetermineResponseErrType, + StaticCheckErrorKind::CouldNotDetermineResponseErrType, ), ( "(unwrap-panic none)", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(define-private (foo) (if (> 1 0) none none)) (unwrap-panic (foo))", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(unwrap-panic (err 3))", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(match none inner-value (/ 1 0) (+ 1 8))", - CheckErrorKind::CouldNotDetermineMatchTypes, + StaticCheckErrorKind::CouldNotDetermineMatchTypes, ), ( "(match (ok 1) ok-val (/ ok-val 0) err-val (+ err-val 7))", - CheckErrorKind::CouldNotDetermineMatchTypes, + StaticCheckErrorKind::CouldNotDetermineMatchTypes, ), ( "(match (err 1) ok-val (/ ok-val 0) err-val (+ err-val 7))", - CheckErrorKind::CouldNotDetermineMatchTypes, + StaticCheckErrorKind::CouldNotDetermineMatchTypes, ), ( "(define-private (foo) (if (> 1 0) (ok 1) (err u8))) (match (foo) ok-val (+ 1 ok-val) err-val (/ err-val u0))", - CheckErrorKind::MatchArmsMustMatch( + StaticCheckErrorKind::MatchArmsMustMatch( Box::new(TypeSignature::IntType), Box::new(TypeSignature::UIntType), ), ), ( "(match (some 1) inner-value (+ 1 inner-value) (> 1 28))", - CheckErrorKind::MatchArmsMustMatch( + StaticCheckErrorKind::MatchArmsMustMatch( Box::new(TypeSignature::IntType), Box::new(TypeSignature::BoolType), ), ), ( "(match (some 1) inner-value (+ 1 inner-value))", - CheckErrorKind::BadMatchOptionSyntax(Box::new(CheckErrorKind::IncorrectArgumentCount( - 4, 3, - ))), + StaticCheckErrorKind::BadMatchOptionSyntax(Box::new( + StaticCheckErrorKind::IncorrectArgumentCount(4, 3), + )), ), ( "(match (ok 1) inner-value (+ 1 inner-value))", - CheckErrorKind::BadMatchResponseSyntax(Box::new( - CheckErrorKind::IncorrectArgumentCount(5, 3), + StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::IncorrectArgumentCount(5, 3), )), ), ( "(match (ok 1) 1 (+ 1 1) err-val (+ 2 err-val))", - CheckErrorKind::BadMatchResponseSyntax(Box::new(CheckErrorKind::ExpectedName)), + StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::ExpectedName, + )), ), ( "(match (ok 1) ok-val (+ 1 1) (+ 3 4) (+ 2 err-val))", - CheckErrorKind::BadMatchResponseSyntax(Box::new(CheckErrorKind::ExpectedName)), + StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::ExpectedName, + )), ), ( "(match (some 1) 2 (+ 1 1) (+ 3 4))", - CheckErrorKind::BadMatchOptionSyntax(Box::new(CheckErrorKind::ExpectedName)), + StaticCheckErrorKind::BadMatchOptionSyntax(Box::new( + StaticCheckErrorKind::ExpectedName, + )), + ), + ( + "(match)", + StaticCheckErrorKind::RequiresAtLeastArguments(1, 0), ), - ("(match)", CheckErrorKind::RequiresAtLeastArguments(1, 0)), ( "(match 1 ok-val (/ ok-val 0) err-val (+ err-val 7))", - CheckErrorKind::BadMatchInput(Box::new(TypeSignature::IntType)), + StaticCheckErrorKind::BadMatchInput(Box::new(TypeSignature::IntType)), ), ( "(default-to 3 5)", - CheckErrorKind::ExpectedOptionalType(Box::new(TypeSignature::IntType)), + StaticCheckErrorKind::ExpectedOptionalType(Box::new(TypeSignature::IntType)), ), ( "(define-private (foo (x int)) (match (some 3) x (+ x 2) 5))", - CheckErrorKind::NameAlreadyUsed("x".to_string()), + StaticCheckErrorKind::NameAlreadyUsed("x".to_string()), ), ( "(define-private (t1 (x uint)) (if (> x u1) (ok x) (err false))) @@ -390,7 +399,7 @@ fn test_destructuring_opts() { (if (> x u4) (err u3) (ok (+ u2 (try! (t1 x))))))", - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( Box::new( TypeSignature::new_response(TypeSignature::NoType, TypeSignature::BoolType) .unwrap(), @@ -405,7 +414,7 @@ fn test_destructuring_opts() { "(define-private (t1 (x uint)) (if (> x u1) (ok x) (err false))) (define-private (t2 (x uint)) (> u2 (try! (t1 x))))", - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( Box::new( TypeSignature::new_response(TypeSignature::NoType, TypeSignature::BoolType) .unwrap(), @@ -415,23 +424,23 @@ fn test_destructuring_opts() { ), ( "(try! (ok 3))", - CheckErrorKind::CouldNotDetermineResponseErrType, + StaticCheckErrorKind::CouldNotDetermineResponseErrType, ), ( "(try! none)", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(try! (err 3))", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(try! 3)", - CheckErrorKind::ExpectedOptionalOrResponseType(Box::new(TypeSignature::IntType)), + StaticCheckErrorKind::ExpectedOptionalOrResponseType(Box::new(TypeSignature::IntType)), ), ( "(try! (ok 3) 4)", - CheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), ), ]; @@ -459,14 +468,14 @@ fn test_at_block() { let bad = [ ( "(at-block (sha512 u0) u1)", - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_32), Box::new(TypeSignature::BUFFER_64), ), ), ( "(at-block (sha256 u0) u1 u2)", - CheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), ), ]; @@ -507,7 +516,7 @@ fn test_trait_reference_unknown() { fn test_unexpected_use_of_field_or_trait_reference() { let bad = [( "(+ 1 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR.contract.field)", - CheckErrorKind::UnexpectedTraitOrFieldReference, + StaticCheckErrorKind::UnexpectedTraitOrFieldReference, )]; for (bad_test, expected) in bad.iter() { @@ -532,12 +541,12 @@ fn test_simple_arithmetic_checks() { "(and (or true false) (+ 1 2 3))", ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::RequiresAtLeastArguments(1, 0), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::UndefinedVariable("x".to_string()), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::RequiresAtLeastArguments(1, 0), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::UndefinedVariable("x".to_string()), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -598,14 +607,14 @@ fn test_simple_hash_checks() { for bad_test in bad_types.iter() { assert!(matches!( *type_check_helper(bad_test).unwrap_err().err, - CheckErrorKind::UnionTypeError(_, _) + StaticCheckErrorKind::UnionTypeError(_, _) )); } for bad_test in invalid_args.iter() { assert!(matches!( *type_check_helper(bad_test).unwrap_err().err, - CheckErrorKind::IncorrectArgumentCount(_, _) + StaticCheckErrorKind::IncorrectArgumentCount(_, _) )); } } @@ -628,10 +637,10 @@ fn test_simple_ifs() { ]; let bad_expected = [ - CheckErrorKind::IfArmsMustMatch(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IfArmsMustMatch(Box::new(ascii_type(1)), Box::new(BoolType)), - CheckErrorKind::IncorrectArgumentCount(3, 0), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IfArmsMustMatch(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IfArmsMustMatch(Box::new(ascii_type(1)), Box::new(BoolType)), + StaticCheckErrorKind::IncorrectArgumentCount(3, 0), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -664,9 +673,9 @@ fn test_simple_lets() { ]; let bad_expected = [ - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_invalid_length(0)), - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_not_atom(0)), - CheckErrorKind::TypeError( + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_invalid_length(0)), + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_not_atom(0)), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::IntType), Box::new(TypeSignature::UIntType), ), @@ -721,26 +730,26 @@ fn test_index_of() { ]; let bad_expected = [ - CheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), - CheckErrorKind::TypeError( + StaticCheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::IntType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_MIN), Box::new(TypeSignature::STRING_ASCII_MIN), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::STRING_UTF8_MIN), Box::new(TypeSignature::STRING_ASCII_MIN), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::STRING_ASCII_MIN), Box::new(TypeSignature::STRING_UTF8_MIN), ), - CheckErrorKind::CouldNotDetermineType, - CheckErrorKind::CouldNotDetermineType, - CheckErrorKind::CouldNotDetermineType, + StaticCheckErrorKind::CouldNotDetermineType, + StaticCheckErrorKind::CouldNotDetermineType, + StaticCheckErrorKind::CouldNotDetermineType, ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { @@ -769,11 +778,11 @@ fn test_element_at() { let bad = ["(element-at (list 1 2 3 4 5) 100)", "(element-at 3 u100)"]; let bad_expected = [ - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::IntType), ), - CheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), + StaticCheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -805,12 +814,12 @@ fn test_eqs() { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::list_of(IntType, 1).unwrap()), Box::new(IntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::from_string( "(optional bool)", ClarityVersion::Clarity1, @@ -852,9 +861,9 @@ fn test_asserts() { ]; let bad_expected = [ - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -918,23 +927,23 @@ fn test_lists() { "(map + (list 1 2 3 4 5) (list true true true true true))", ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(2, 3), - CheckErrorKind::UnknownFunction("ynot".to_string()), - CheckErrorKind::IllegalOrUnknownFunctionApplication("if".to_string()), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::UnionTypeError(vec![IntType, UIntType], Box::new(BoolType)), - CheckErrorKind::ExpectedSequence(Box::new(UIntType)), - CheckErrorKind::ExpectedSequence(Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::UnknownFunction("ynot".to_string()), + StaticCheckErrorKind::IllegalOrUnknownFunctionApplication("if".to_string()), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::UnionTypeError(vec![IntType, UIntType], Box::new(BoolType)), + StaticCheckErrorKind::ExpectedSequence(Box::new(UIntType)), + StaticCheckErrorKind::ExpectedSequence(Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -975,20 +984,20 @@ fn test_buff() { "(len 1)", ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(2, 3), - CheckErrorKind::UnknownFunction("ynot".to_string()), - CheckErrorKind::IllegalOrUnknownFunctionApplication("if".to_string()), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::UnionTypeError(vec![IntType, UIntType], Box::new(BoolType)), - CheckErrorKind::ExpectedSequence(Box::new(UIntType)), - CheckErrorKind::ExpectedSequence(Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::UnknownFunction("ynot".to_string()), + StaticCheckErrorKind::IllegalOrUnknownFunctionApplication("if".to_string()), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::UnionTypeError(vec![IntType, UIntType], Box::new(BoolType)), + StaticCheckErrorKind::ExpectedSequence(Box::new(UIntType)), + StaticCheckErrorKind::ExpectedSequence(Box::new(IntType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -1063,9 +1072,9 @@ fn test_native_as_max_len() { "(as-max-len? 0x01 u1048577)", ]; let bad_expected = [ - CheckErrorKind::ValueTooLarge, - CheckErrorKind::ValueTooLarge, - CheckErrorKind::ValueTooLarge, + StaticCheckErrorKind::ValueTooLarge, + StaticCheckErrorKind::ValueTooLarge, + StaticCheckErrorKind::ValueTooLarge, ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { assert_eq!(*expected, *type_check_helper(bad_test).unwrap_err().err); @@ -1109,9 +1118,9 @@ fn test_native_append() { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { assert_eq!(*expected, *type_check_helper(bad_test).unwrap_err().err); @@ -1137,9 +1146,9 @@ fn test_native_concat() { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { assert_eq!(*expected, *type_check_helper(bad_test).unwrap_err().err); @@ -1235,8 +1244,8 @@ fn test_tuples() { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -1266,7 +1275,7 @@ fn test_empty_tuple_should_fail() { ) .unwrap_err() .err, - CheckErrorKind::EmptyTuplesNotAllowed + StaticCheckErrorKind::EmptyTuplesNotAllowed ); } @@ -1362,9 +1371,9 @@ fn test_simple_uints() { let bad = ["(> u1 1)", "(to-uint true)", "(to-int false)"]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(BoolType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -1425,7 +1434,7 @@ fn test_response_inference() { ]; let bad_expected = [ - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::from_string( "(response bool int)", ClarityVersion::Clarity1, @@ -1433,8 +1442,8 @@ fn test_response_inference() { )), Box::new(BoolType), ), - CheckErrorKind::ReturnTypesMustMatch(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::ReturnTypesMustMatch(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -1572,7 +1581,7 @@ fn test_options() { .unwrap_err() .err { - CheckErrorKind::TypeError(t1, t2) => { + StaticCheckErrorKind::TypeError(t1, t2) => { *t1 == TypeSignature::from_string( "(optional bool)", ClarityVersion::Clarity1, @@ -1724,7 +1733,7 @@ fn test_missing_value_on_declaration_should_fail() { .unwrap_err(); assert!(matches!( *res.err, - CheckErrorKind::IncorrectArgumentCount(_, _) + StaticCheckErrorKind::IncorrectArgumentCount(_, _) )); } @@ -1740,7 +1749,7 @@ fn test_mismatching_type_on_declaration_should_fail() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } #[test] @@ -1761,7 +1770,7 @@ fn test_mismatching_type_on_update_should_fail() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } #[test] @@ -1778,7 +1787,10 @@ fn test_direct_access_to_persisted_var_should_fail() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::UndefinedVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::UndefinedVariable(_) + )); } #[test] @@ -1798,7 +1810,7 @@ fn test_data_var_shadowed_by_let_should_fail() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NameAlreadyUsed(_))); + assert!(matches!(*res.err, StaticCheckErrorKind::NameAlreadyUsed(_))); } #[test] @@ -1816,7 +1828,10 @@ fn test_mutating_unknown_data_var_should_fail() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NoSuchDataVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::NoSuchDataVariable(_) + )); } #[test] @@ -1832,7 +1847,10 @@ fn test_accessing_unknown_data_var_should_fail() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NoSuchDataVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::NoSuchDataVariable(_) + )); } #[test] @@ -1848,7 +1866,7 @@ fn test_let_shadowed_by_let_should_fail() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NameAlreadyUsed(_))); + assert!(matches!(*res.err, StaticCheckErrorKind::NameAlreadyUsed(_))); } #[test] @@ -1865,7 +1883,7 @@ fn test_let_shadowed_by_nested_let_should_fail() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NameAlreadyUsed(_))); + assert!(matches!(*res.err, StaticCheckErrorKind::NameAlreadyUsed(_))); } #[test] @@ -1883,7 +1901,7 @@ fn test_define_constant_shadowed_by_let_should_fail() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NameAlreadyUsed(_))); + assert!(matches!(*res.err, StaticCheckErrorKind::NameAlreadyUsed(_))); } #[test] @@ -1900,7 +1918,7 @@ fn test_define_constant_shadowed_by_argument_should_fail() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NameAlreadyUsed(_))); + assert!(matches!(*res.err, StaticCheckErrorKind::NameAlreadyUsed(_))); } #[test] @@ -2122,7 +2140,7 @@ fn test_fetch_entry_mismatching_type_signatures() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } } @@ -2142,7 +2160,10 @@ fn test_fetch_entry_unbound_variables() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::UndefinedVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::UndefinedVariable(_) + )); } } @@ -2194,7 +2215,7 @@ fn test_insert_entry_mismatching_type_signatures() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } } @@ -2217,7 +2238,10 @@ fn test_insert_entry_unbound_variables() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::UndefinedVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::UndefinedVariable(_) + )); } } @@ -2267,7 +2291,7 @@ fn test_delete_entry_mismatching_type_signatures() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } } @@ -2287,7 +2311,10 @@ fn test_delete_entry_unbound_variables() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::UndefinedVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::UndefinedVariable(_) + )); } } @@ -2341,7 +2368,7 @@ fn test_set_entry_mismatching_type_signatures() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } } @@ -2364,7 +2391,10 @@ fn test_set_entry_unbound_variables() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::UndefinedVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::UndefinedVariable(_) + )); } } @@ -2499,7 +2529,7 @@ fn test_buff_negative_len() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert_eq!(*res.err, CheckErrorKind::ValueOutOfBounds); + assert_eq!(*res.err, StaticCheckErrorKind::ValueOutOfBounds); } #[test] @@ -2513,7 +2543,7 @@ fn test_string_ascii_negative_len() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert_eq!(*res.err, CheckErrorKind::ValueOutOfBounds); + assert_eq!(*res.err, StaticCheckErrorKind::ValueOutOfBounds); } #[test] @@ -2527,5 +2557,5 @@ fn test_string_utf8_negative_len() { StacksEpochId::Epoch2_05, ) .unwrap_err(); - assert_eq!(*res.err, CheckErrorKind::ValueOutOfBounds); + assert_eq!(*res.err, StaticCheckErrorKind::ValueOutOfBounds); } diff --git a/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs b/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs index 7632ea305bb..c8998b90190 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs @@ -16,7 +16,7 @@ use std::collections::{BTreeMap, HashMap, HashSet}; -use crate::vm::analysis::errors::{CheckErrorKind, StaticCheckError}; +use crate::vm::analysis::errors::{StaticCheckError, StaticCheckErrorKind}; use crate::vm::analysis::type_checker::is_reserved_word; use crate::vm::analysis::types::ContractAnalysis; use crate::vm::representations::ClarityName; @@ -169,7 +169,7 @@ impl ContractContext { pub fn check_name_used(&self, name: &str) -> Result<(), StaticCheckError> { if is_reserved_word(name, self.clarity_version) { - return Err(StaticCheckError::new(CheckErrorKind::ReservedWord( + return Err(StaticCheckError::new(StaticCheckErrorKind::ReservedWord( name.to_string(), ))); } @@ -183,9 +183,9 @@ impl ContractContext { || self.traits.is_name_used(name) || self.map_types.contains_key(name) { - Err(StaticCheckError::new(CheckErrorKind::NameAlreadyUsed( - name.to_string(), - ))) + Err(StaticCheckError::new( + StaticCheckErrorKind::NameAlreadyUsed(name.to_string()), + )) } else { Ok(()) } diff --git a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs index d2b17abc3b6..b150ed72e6c 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs @@ -26,8 +26,8 @@ pub use self::natives::{SimpleNativeFunction, TypedNativeFunction}; use super::contexts::{TypeMap, TypingContext}; use super::ContractAnalysis; pub use crate::vm::analysis::errors::{ - check_argument_count, check_arguments_at_least, check_arguments_at_most, CheckErrorKind, - StaticCheckError, SyntaxBindingErrorType, + check_argument_count, check_arguments_at_least, check_arguments_at_most, + StaticCheckError, StaticCheckErrorKind, SyntaxBindingErrorType, }; use crate::vm::analysis::AnalysisDatabase; use crate::vm::costs::cost_functions::ClarityCostFunction; @@ -161,14 +161,6 @@ pub fn compute_typecheck_cost( ) } -pub fn check_argument_len(expected: usize, args_len: usize) -> Result<(), CheckErrorKind> { - if args_len != expected { - Err(CheckErrorKind::IncorrectArgumentCount(expected, args_len)) - } else { - Ok(()) - } -} - impl FunctionType { #[allow(clippy::type_complexity)] pub fn check_args_visitor_2_1( @@ -192,7 +184,7 @@ impl FunctionType { if !admitted { return ( cost, - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(arg_type.clone()), ) @@ -211,7 +203,7 @@ impl FunctionType { let return_type = match arg_type { TypeSignature::IntType => Ok(Some(TypeSignature::IntType)), TypeSignature::UIntType => Ok(Some(TypeSignature::UIntType)), - _ => Err(CheckErrorKind::UnionTypeError( + _ => Err(StaticCheckErrorKind::UnionTypeError( vec![TypeSignature::IntType, TypeSignature::UIntType], Box::new(arg_type.clone()), ) @@ -220,10 +212,10 @@ impl FunctionType { (cost, return_type) } else { let return_type = accumulated_type - .ok_or_else(|| CheckErrorKind::Expects("Failed to set accumulated type for arg indices >= 1 in variadic arithmetic".into()).into()); + .ok_or_else(|| StaticCheckErrorKind::Expects("Failed to set accumulated type for arg indices >= 1 in variadic arithmetic".into()).into()); let check_result = return_type.and_then(|return_type| { if arg_type != return_type { - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(return_type.clone()), Box::new(arg_type.clone()), ) @@ -246,10 +238,11 @@ impl FunctionType { // note: argument count will be wrong? return ( None, - Err( - CheckErrorKind::IncorrectArgumentCount(arg_types.len(), arg_index) - .into(), - ), + Err(StaticCheckErrorKind::IncorrectArgumentCount( + arg_types.len(), + arg_index, + ) + .into()), ); } (None, Ok(None)) @@ -262,7 +255,7 @@ impl FunctionType { if arg_index >= 1 { return ( None, - Err(CheckErrorKind::IncorrectArgumentCount(1, arg_index).into()), + Err(StaticCheckErrorKind::IncorrectArgumentCount(1, arg_index).into()), ); } (None, Ok(None)) @@ -273,7 +266,7 @@ impl FunctionType { if arg_index >= 2 { return ( None, - Err(CheckErrorKind::IncorrectArgumentCount(2, arg_index).into()), + Err(StaticCheckErrorKind::IncorrectArgumentCount(2, arg_index).into()), ); } (None, Ok(None)) @@ -293,7 +286,7 @@ impl FunctionType { for found_type in args.iter() { analysis_typecheck_cost(accounting, expected_type, found_type)?; if !expected_type.admits_type(&StacksEpochId::Epoch21, found_type)? { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(found_type.clone()), ) @@ -311,7 +304,7 @@ impl FunctionType { { analysis_typecheck_cost(accounting, expected_type, found_type)?; if !expected_type.admits_type(&StacksEpochId::Epoch21, found_type)? { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(found_type.clone()), ) @@ -329,10 +322,11 @@ impl FunctionType { return Ok(return_type.clone()); } } - Err( - CheckErrorKind::UnionTypeError(arg_types.clone(), Box::new(found_type.clone())) - .into(), + Err(StaticCheckErrorKind::UnionTypeError( + arg_types.clone(), + Box::new(found_type.clone()), ) + .into()) } FunctionType::Binary(left_arg_sig, right_arg_sig, return_sig) => { check_argument_count(2, args)?; @@ -357,14 +351,17 @@ impl FunctionType { if self == &FunctionType::ArithmeticBinary { check_argument_count(2, args)?; } - let (first, rest) = args - .split_first() - .ok_or(CheckErrorKind::RequiresAtLeastArguments(1, args.len()))?; + let (first, rest) = + args.split_first() + .ok_or(StaticCheckErrorKind::RequiresAtLeastArguments( + 1, + args.len(), + ))?; analysis_typecheck_cost(accounting, &TypeSignature::IntType, first)?; let return_type = match first { TypeSignature::IntType => Ok(TypeSignature::IntType), TypeSignature::UIntType => Ok(TypeSignature::UIntType), - _ => Err(CheckErrorKind::UnionTypeError( + _ => Err(StaticCheckErrorKind::UnionTypeError( vec![TypeSignature::IntType, TypeSignature::UIntType], Box::new(first.clone()), )), @@ -372,7 +369,7 @@ impl FunctionType { for found_type in rest.iter() { analysis_typecheck_cost(accounting, &TypeSignature::IntType, found_type)?; if found_type != &return_type { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(return_type.clone()), Box::new(found_type.clone()), ) @@ -406,7 +403,7 @@ impl FunctionType { }; if !first_type_supported { - return Err(CheckErrorKind::UnionTypeError( + return Err(StaticCheckErrorKind::UnionTypeError( vec![ TypeSignature::IntType, TypeSignature::UIntType, @@ -448,7 +445,7 @@ impl FunctionType { }; if !pair_of_types_matches { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(first.clone()), Box::new(second.clone()), ) @@ -493,7 +490,7 @@ impl FunctionType { depth: u8, ) -> Result { if depth > MAX_TYPE_DEPTH { - return Err(CheckErrorKind::TypeSignatureTooDeep.into()); + return Err(StaticCheckErrorKind::TypeSignatureTooDeep.into()); } Ok(match value { @@ -563,7 +560,9 @@ impl FunctionType { ) -> Result { let (expected_args, returns) = match self { FunctionType::Fixed(FixedFunction { args, returns }) => (args, returns), - _ => return Err(CheckErrorKind::Expects("Unexpected function type".into()).into()), + _ => { + return Err(StaticCheckErrorKind::Expects("Unexpected function type".into()).into()) + } }; check_argument_count(expected_args.len(), func_args)?; @@ -577,7 +576,7 @@ impl FunctionType { let contract_to_check = db .load_contract(contract, &StacksEpochId::Epoch21)? .ok_or_else(|| { - CheckErrorKind::NoSuchContract(contract.name.to_string()) + StaticCheckErrorKind::NoSuchContract(contract.name.to_string()) })?; let trait_definition = db .get_defined_trait( @@ -585,8 +584,10 @@ impl FunctionType { &trait_id.name, &StacksEpochId::Epoch21, ) - .map_err(|_| CheckErrorKind::Expects("Failed to get trait".into()))? - .ok_or(CheckErrorKind::NoSuchContract( + .map_err(|_| { + StaticCheckErrorKind::Expects("Failed to get trait".into()) + })? + .ok_or(StaticCheckErrorKind::NoSuchContract( trait_id.contract_identifier.to_string(), ))?; contract_to_check.check_trait_compliance( @@ -598,7 +599,7 @@ impl FunctionType { (expected_type, value) => { if !expected_type.admits(&StacksEpochId::Epoch21, value)? { let actual_type = TypeSignature::type_of(value)?; - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(actual_type.clone()), ) @@ -637,7 +638,7 @@ fn check_function_arg_signature( FunctionArgSignature::Single(expected_type) => { analysis_typecheck_cost(cost_tracker, expected_type, actual_type)?; if !expected_type.admits_type(&StacksEpochId::Epoch21, actual_type)? { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(actual_type.clone()), ) @@ -654,7 +655,7 @@ fn check_function_arg_signature( } } if !admitted { - return Err(CheckErrorKind::UnionTypeError( + return Err(StaticCheckErrorKind::UnionTypeError( expected_types.clone(), Box::new(actual_type.clone()), ) @@ -735,14 +736,14 @@ pub fn clarity2_trait_check_trait_compliance( func, tracker, ) { - return Err(CheckErrorKind::IncompatibleTrait( + return Err(StaticCheckErrorKind::IncompatibleTrait( Box::new(expected_trait_identifier.clone()), Box::new(actual_trait_identifier.clone()), ) .into()); } } else { - return Err(CheckErrorKind::IncompatibleTrait( + return Err(StaticCheckErrorKind::IncompatibleTrait( Box::new(expected_trait_identifier.clone()), Box::new(actual_trait_identifier.clone()), ) @@ -763,7 +764,7 @@ fn clarity2_inner_type_check_type( tracker: &mut T, ) -> Result { if depth > MAX_TYPE_DEPTH { - return Err(CheckErrorKind::TypeSignatureTooDeep.into()); + return Err(StaticCheckErrorKind::TypeSignatureTooDeep.into()); } // Recurse into values to check embedded traits properly @@ -816,7 +817,7 @@ fn clarity2_inner_type_check_type( tracker, )?; } else { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(actual_type.clone()), ) @@ -828,7 +829,7 @@ fn clarity2_inner_type_check_type( TypeSignature::TupleType(expected_tuple_type), ) => { if expected_tuple_type.get_type_map().len() != atom_tuple_type.get_type_map().len() { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(actual_type.clone()), ) @@ -848,7 +849,7 @@ fn clarity2_inner_type_check_type( )?; } None => { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(actual_type.clone()), ) @@ -881,24 +882,24 @@ fn clarity2_inner_type_check_type( TypeSignature::CallableType(CallableSubtype::Principal(contract_identifier)), TypeSignature::CallableType(CallableSubtype::Trait(expected_trait_id)), ) => { - let contract_to_check = match db - .load_contract(contract_identifier, &StacksEpochId::Epoch21)? - { - Some(contract) => { - runtime_cost( - ClarityCostFunction::AnalysisFetchContractEntry, - tracker, - contract_analysis_size(&contract)?, - )?; - contract - } - None => { - runtime_cost(ClarityCostFunction::AnalysisFetchContractEntry, tracker, 1)?; - return Err( - CheckErrorKind::NoSuchContract(contract_identifier.to_string()).into(), - ); - } - }; + let contract_to_check = + match db.load_contract(contract_identifier, &StacksEpochId::Epoch21)? { + Some(contract) => { + runtime_cost( + ClarityCostFunction::AnalysisFetchContractEntry, + tracker, + contract_analysis_size(&contract)?, + )?; + contract + } + None => { + runtime_cost(ClarityCostFunction::AnalysisFetchContractEntry, tracker, 1)?; + return Err(StaticCheckErrorKind::NoSuchContract( + contract_identifier.to_string(), + ) + .into()); + } + }; let expected_trait = clarity2_lookup_trait(db, contract_context, expected_trait_id, tracker)?; contract_to_check.check_trait_compliance( @@ -926,7 +927,7 @@ fn clarity2_inner_type_check_type( (TypeSignature::NoType, _) => (), (_, _) => { if !expected_type.admits_type(&StacksEpochId::Epoch21, actual_type)? { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(actual_type.clone()), ) @@ -948,7 +949,7 @@ fn clarity2_lookup_trait( if contract_context.is_contract(&trait_id.contract_identifier) { return Ok(contract_context .get_trait(trait_id) - .ok_or(CheckErrorKind::NoSuchTrait( + .ok_or(StaticCheckErrorKind::NoSuchTrait( trait_id.contract_identifier.to_string(), trait_id.name.to_string(), ))? @@ -975,7 +976,7 @@ fn clarity2_lookup_trait( } Ok(None) => { runtime_cost(ClarityCostFunction::AnalysisUseTraitEntry, tracker, 1)?; - Err(CheckErrorKind::NoSuchTrait( + Err(StaticCheckErrorKind::NoSuchTrait( trait_id.contract_identifier.to_string(), trait_id.name.to_string(), ) @@ -1013,14 +1014,14 @@ fn type_reserved_variable( let var_type = match variable { TxSender => TypeSignature::PrincipalType, TxSponsor => TypeSignature::new_option(TypeSignature::PrincipalType) - .map_err(|_| CheckErrorKind::Expects("Bad construction".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad construction".into()))?, ContractCaller => TypeSignature::PrincipalType, BlockHeight => TypeSignature::UIntType, StacksBlockHeight => TypeSignature::UIntType, TenureHeight => TypeSignature::UIntType, BurnBlockHeight => TypeSignature::UIntType, NativeNone => TypeSignature::new_option(no_type()) - .map_err(|_| CheckErrorKind::Expects("Bad construction".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad construction".into()))?, NativeTrue => TypeSignature::BoolType, NativeFalse => TypeSignature::BoolType, TotalLiquidMicroSTX => TypeSignature::UIntType, @@ -1089,7 +1090,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { &return_type, ) .map_err(|_| { - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( Box::new(expected_type), Box::new(return_type), ) @@ -1120,7 +1121,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { } Err(e) => Err(e), })? - .ok_or_else(|| CheckErrorKind::Expects("Expected a depth result".into()))?; + .ok_or_else(|| StaticCheckErrorKind::Expects("Expected a depth result".into()))?; } runtime_cost(ClarityCostFunction::AnalysisStorage, self, size)?; @@ -1195,15 +1196,16 @@ impl<'a, 'b> TypeChecker<'a, 'b> { let type_return = self.type_check(&args[ix], context)?; if ix + 1 < args.len() { if type_return.is_response_type() { - return_failure = Err(CheckErrorKind::UncheckedIntermediaryResponses); + return_failure = Err(StaticCheckErrorKind::UncheckedIntermediaryResponses); } } else { last_return = Some(type_return); } } - let last_return = last_return - .ok_or_else(|| StaticCheckError::new(CheckErrorKind::CheckerImplementationFailure))?; + let last_return = last_return.ok_or_else(|| { + StaticCheckError::new(StaticCheckErrorKind::CheckerImplementationFailure) + })?; return_failure?; Ok(last_return) @@ -1266,9 +1268,13 @@ impl<'a, 'b> TypeChecker<'a, 'b> { } } if let Err(mut check_error) = check_result { - if let CheckErrorKind::IncorrectArgumentCount(expected, _actual) = *check_error.err { - check_error.err = - Box::new(CheckErrorKind::IncorrectArgumentCount(expected, args.len())); + if let StaticCheckErrorKind::IncorrectArgumentCount(expected, _actual) = + *check_error.err + { + check_error.err = Box::new(StaticCheckErrorKind::IncorrectArgumentCount( + expected, + args.len(), + )); check_error.diagnostic = Diagnostic::err(check_error.err.as_ref()); } // accumulate the checking costs @@ -1298,10 +1304,10 @@ impl<'a, 'b> TypeChecker<'a, 'b> { ) -> Result<(ClarityName, FixedFunction), StaticCheckError> { let (function_name, args) = signature .split_first() - .ok_or(CheckErrorKind::RequiresAtLeastArguments(1, 0))?; + .ok_or(StaticCheckErrorKind::RequiresAtLeastArguments(1, 0))?; let function_name = function_name .match_atom() - .ok_or(CheckErrorKind::BadFunctionName)?; + .ok_or(StaticCheckErrorKind::BadFunctionName)?; let args = parse_name_type_pairs::<(), StaticCheckError>( StacksEpochId::Epoch21, args, @@ -1310,7 +1316,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { )?; if self.function_return_tracker.is_some() { - return Err(CheckErrorKind::Expects( + return Err(StaticCheckErrorKind::Expects( "Interpreter error: Previous function define left dirty typecheck state.".into(), ) .into()); @@ -1366,7 +1372,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { &return_type, ) .map_err(|_| { - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( Box::new(expected.clone()), Box::new(return_type), ) @@ -1406,10 +1412,10 @@ impl<'a, 'b> TypeChecker<'a, 'b> { // should we set the type of the subexpressions of the signature to no-type as well? let key_type = TypeSignature::parse_type_repr(StacksEpochId::Epoch21, key_type, &mut ()) - .map_err(|_| CheckErrorKind::BadMapTypeDefinition)?; + .map_err(|_| StaticCheckErrorKind::BadMapTypeDefinition)?; let value_type = TypeSignature::parse_type_repr(StacksEpochId::Epoch21, value_type, &mut ()) - .map_err(|_| CheckErrorKind::BadMapTypeDefinition)?; + .map_err(|_| StaticCheckErrorKind::BadMapTypeDefinition)?; Ok((map_name.clone(), (key_type, value_type))) } @@ -1441,19 +1447,21 @@ impl<'a, 'b> TypeChecker<'a, 'b> { ) -> Result { let (function_name, args) = expression .split_first() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; self.type_map.set_type(function_name, no_type())?; let function_name = function_name .match_atom() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; if let Some(type_result) = self.try_native_function_check(function_name, args, context) { type_result } else { let function = match self.get_function_type(function_name) { Some(FunctionType::Fixed(function)) => Ok(function), - _ => Err(CheckErrorKind::UnknownFunction(function_name.to_string())), + _ => Err(StaticCheckErrorKind::UnknownFunction( + function_name.to_string(), + )), }?; for (expected_type, found_type) in function.args.iter().map(|x| &x.signature).zip(args) @@ -1485,7 +1493,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { // be undefined. This early error prevents a cost function error // due to `context.depth` being 0. if context.depth == 0 { - return Err(CheckErrorKind::UndefinedVariable(name.to_string()).into()); + return Err(StaticCheckErrorKind::UndefinedVariable(name.to_string()).into()); } runtime_cost( @@ -1497,7 +1505,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { if let Some(type_result) = context.lookup_variable_type(name) { Ok(type_result.clone()) } else { - Err(CheckErrorKind::UndefinedVariable(name.to_string()).into()) + Err(StaticCheckErrorKind::UndefinedVariable(name.to_string()).into()) } } } @@ -1516,7 +1524,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { let contract_to_check = self .db .load_contract(contract_identifier, &StacksEpochId::Epoch21)? - .ok_or(CheckErrorKind::NoSuchContract( + .ok_or(StaticCheckErrorKind::NoSuchContract( contract_identifier.to_string(), ))?; @@ -1526,13 +1534,13 @@ impl<'a, 'b> TypeChecker<'a, 'b> { &trait_identifier.contract_identifier, &StacksEpochId::Epoch21, )? - .ok_or(CheckErrorKind::NoSuchContract( + .ok_or(StaticCheckErrorKind::NoSuchContract( trait_identifier.contract_identifier.to_string(), ))?; let trait_definition = contract_defining_trait .get_defined_trait(&trait_identifier.name) - .ok_or(CheckErrorKind::NoSuchTrait( + .ok_or(StaticCheckErrorKind::NoSuchTrait( trait_identifier.contract_identifier.to_string(), trait_identifier.name.to_string(), ))?; @@ -1549,7 +1557,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { analysis_typecheck_cost(self, expected_type, &actual_type)?; if !expected_type.admits_type(&StacksEpochId::Epoch21, &actual_type)? { - let mut err: StaticCheckError = CheckErrorKind::TypeError( + let mut err: StaticCheckError = StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(actual_type.clone()), ) @@ -1573,7 +1581,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { Atom(ref name) => self.lookup_variable(name, context)?, List(ref expression) => self.type_check_function_application(expression, context)?, TraitReference(_, _) | Field(_) => { - return Err(CheckErrorKind::UnexpectedTraitOrFieldReference.into()); + return Err(StaticCheckErrorKind::UnexpectedTraitOrFieldReference.into()); } }; @@ -1611,7 +1619,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { Atom(ref name) => self.lookup_variable(name, context)?, List(ref expression) => self.type_check_function_application(expression, context)?, TraitReference(_, _) | Field(_) => { - return Err(CheckErrorKind::UnexpectedTraitOrFieldReference.into()); + return Err(StaticCheckErrorKind::UnexpectedTraitOrFieldReference.into()); } }; @@ -1643,7 +1651,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { ) -> Result<(ClarityName, TypeSignature), StaticCheckError> { let expected_type = TypeSignature::parse_type_repr::<()>(StacksEpochId::Epoch21, var_type, &mut ()) - .map_err(|_e| CheckErrorKind::DefineVariableBadSignature)?; + .map_err(|_e| StaticCheckErrorKind::DefineVariableBadSignature)?; self.type_check_expects(initial, context, &expected_type)?; @@ -1671,7 +1679,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { ) -> Result<(ClarityName, TypeSignature), StaticCheckError> { let asset_type = TypeSignature::parse_type_repr::<()>(StacksEpochId::Epoch21, nft_type, &mut ()) - .map_err(|_| CheckErrorKind::DefineNFTBadSignature)?; + .map_err(|_| StaticCheckErrorKind::DefineNFTBadSignature)?; Ok((asset_name.clone(), asset_type)) } @@ -1746,9 +1754,9 @@ impl<'a, 'b> TypeChecker<'a, 'b> { .add_public_function_type(f_name, FunctionType::Fixed(f_type))?; return Ok(Some(())); } else { - return Err(CheckErrorKind::PublicFunctionMustReturnResponse(Box::new( - f_type.returns, - )) + return Err(StaticCheckErrorKind::PublicFunctionMustReturnResponse( + Box::new(f_type.returns), + ) .into()); } } @@ -1889,9 +1897,10 @@ impl<'a, 'b> TypeChecker<'a, 'b> { None => { // still had to do a db read, even if it didn't exist! runtime_cost(ClarityCostFunction::AnalysisUseTraitEntry, self, 1)?; - return Err( - CheckErrorKind::TraitReferenceUnknown(name.to_string()).into() - ); + return Err(StaticCheckErrorKind::TraitReferenceUnknown( + name.to_string(), + ) + .into()); } } } diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs index 098300af775..b6461217d75 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs @@ -17,7 +17,9 @@ use stacks_common::consts::TOKEN_TRANSFER_MEMO_LENGTH; use super::{TypeChecker, TypingContext}; -use crate::vm::analysis::errors::{check_argument_count, CheckErrorKind, StaticCheckError}; +use crate::vm::analysis::errors::{ + check_argument_count, StaticCheckError, StaticCheckErrorKind, +}; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::runtime_cost; use crate::vm::representations::SymbolicExpression; @@ -30,13 +32,15 @@ pub fn check_special_get_owner( ) -> Result { check_argument_count(2, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_asset_type = checker .contract_context .get_nft_type(asset_name) .cloned() - .ok_or_else(|| CheckErrorKind::NoSuchNFT(asset_name.to_string()))?; + .ok_or_else(|| StaticCheckErrorKind::NoSuchNFT(asset_name.to_string()))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -58,10 +62,12 @@ pub fn check_special_get_balance( ) -> Result { check_argument_count(2, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; if !checker.contract_context.ft_exists(asset_name) { - return Err(CheckErrorKind::NoSuchFT(asset_name.to_string()).into()); + return Err(StaticCheckErrorKind::NoSuchFT(asset_name.to_string()).into()); } runtime_cost(ClarityCostFunction::AnalysisTypeLookup, checker, 1)?; @@ -79,13 +85,15 @@ pub fn check_special_mint_asset( ) -> Result { check_argument_count(3, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; let expected_asset_type = checker .contract_context .get_nft_type(asset_name) - .ok_or(CheckErrorKind::NoSuchNFT(asset_name.to_string()))? + .ok_or(StaticCheckErrorKind::NoSuchNFT(asset_name.to_string()))? .clone(); // this clone shouldn't be strictly necessary, but to use `type_check_expects` with this, it would have to be. runtime_cost( @@ -110,7 +118,9 @@ pub fn check_special_mint_token( ) -> Result { check_argument_count(3, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_amount: TypeSignature = TypeSignature::UIntType; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; @@ -121,7 +131,7 @@ pub fn check_special_mint_token( checker.type_check_expects(&args[2], context, &expected_owner_type)?; if !checker.contract_context.ft_exists(asset_name) { - return Err(CheckErrorKind::NoSuchFT(asset_name.to_string()).into()); + return Err(StaticCheckErrorKind::NoSuchFT(asset_name.to_string()).into()); } Ok(TypeSignature::ResponseType(Box::new(( @@ -137,13 +147,15 @@ pub fn check_special_transfer_asset( ) -> Result { check_argument_count(4, args)?; - let token_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let token_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; let expected_asset_type = checker .contract_context .get_nft_type(token_name) - .ok_or(CheckErrorKind::NoSuchNFT(token_name.to_string()))? + .ok_or(StaticCheckErrorKind::NoSuchNFT(token_name.to_string()))? .clone(); runtime_cost( @@ -169,7 +181,9 @@ pub fn check_special_transfer_token( ) -> Result { check_argument_count(4, args)?; - let token_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let token_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_amount: TypeSignature = TypeSignature::UIntType; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; @@ -181,7 +195,7 @@ pub fn check_special_transfer_token( checker.type_check_expects(&args[3], context, &expected_owner_type)?; // recipient if !checker.contract_context.ft_exists(token_name) { - return Err(CheckErrorKind::NoSuchFT(token_name.to_string()).into()); + return Err(StaticCheckErrorKind::NoSuchFT(token_name.to_string()).into()); } Ok(TypeSignature::ResponseType(Box::new(( @@ -225,7 +239,7 @@ pub fn check_special_stx_transfer_memo( let to_type: TypeSignature = TypeSignature::PrincipalType; let memo_type: TypeSignature = TypeSignature::SequenceType(SequenceSubtype::BufferType( BufferLength::try_from(TOKEN_TRANSFER_MEMO_LENGTH as u32) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, )); runtime_cost(ClarityCostFunction::AnalysisTypeLookup, checker, 0)?; @@ -248,10 +262,12 @@ pub fn check_special_get_token_supply( ) -> Result { check_argument_count(1, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; if !checker.contract_context.ft_exists(asset_name) { - return Err(CheckErrorKind::NoSuchFT(asset_name.to_string()).into()); + return Err(StaticCheckErrorKind::NoSuchFT(asset_name.to_string()).into()); } runtime_cost(ClarityCostFunction::AnalysisTypeLookup, checker, 1)?; @@ -266,13 +282,15 @@ pub fn check_special_burn_asset( ) -> Result { check_argument_count(3, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; let expected_asset_type = checker .contract_context .get_nft_type(asset_name) - .ok_or(CheckErrorKind::NoSuchNFT(asset_name.to_string()))? + .ok_or(StaticCheckErrorKind::NoSuchNFT(asset_name.to_string()))? .clone(); // this clone shouldn't be strictly necessary, but to use `type_check_expects` with this, it would have to be. runtime_cost( @@ -297,7 +315,9 @@ pub fn check_special_burn_token( ) -> Result { check_argument_count(3, args)?; - let asset_name = args[0].match_atom().ok_or(CheckErrorKind::BadTokenName)?; + let asset_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadTokenName)?; let expected_amount: TypeSignature = TypeSignature::UIntType; let expected_owner_type: TypeSignature = TypeSignature::PrincipalType; @@ -308,7 +328,7 @@ pub fn check_special_burn_token( checker.type_check_expects(&args[2], context, &expected_owner_type)?; if !checker.contract_context.ft_exists(asset_name) { - return Err(CheckErrorKind::NoSuchFT(asset_name.to_string()).into()); + return Err(StaticCheckErrorKind::NoSuchFT(asset_name.to_string()).into()); } Ok(TypeSignature::ResponseType(Box::new(( diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs index 0b95c44f86c..ca520bced38 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs @@ -17,7 +17,8 @@ use stacks_common::types::StacksEpochId; use crate::vm::analysis::type_checker::v2_1::{ - check_arguments_at_least, CheckErrorKind, StaticCheckError, TypeChecker, TypingContext, + check_arguments_at_least, StaticCheckError, StaticCheckErrorKind, TypeChecker, + TypingContext, }; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, runtime_cost}; @@ -31,14 +32,16 @@ pub fn check_special_fetch_entry( ) -> Result { check_arguments_at_least(2, args)?; - let map_name = args[0].match_atom().ok_or(CheckErrorKind::BadMapName)?; + let map_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadMapName)?; let key_type = checker.type_check(&args[1], context)?; let (expected_key_type, value_type) = checker .contract_context .get_map_type(map_name) - .ok_or(CheckErrorKind::NoSuchMap(map_name.to_string()))?; + .ok_or(StaticCheckErrorKind::NoSuchMap(map_name.to_string()))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -55,7 +58,7 @@ pub fn check_special_fetch_entry( let option_type = TypeSignature::new_option(value_type.clone())?; if !expected_key_type.admits_type(&StacksEpochId::Epoch21, &key_type)? { - Err(StaticCheckError::new(CheckErrorKind::TypeError( + Err(StaticCheckError::new(StaticCheckErrorKind::TypeError( Box::new(expected_key_type.clone()), Box::new(key_type), ))) @@ -71,14 +74,16 @@ pub fn check_special_delete_entry( ) -> Result { check_arguments_at_least(2, args)?; - let map_name = args[0].match_atom().ok_or(CheckErrorKind::BadMapName)?; + let map_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadMapName)?; let key_type = checker.type_check(&args[1], context)?; let (expected_key_type, _) = checker .contract_context .get_map_type(map_name) - .ok_or(CheckErrorKind::NoSuchMap(map_name.to_string()))?; + .ok_or(StaticCheckErrorKind::NoSuchMap(map_name.to_string()))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -88,7 +93,7 @@ pub fn check_special_delete_entry( analysis_typecheck_cost(&mut checker.cost_track, expected_key_type, &key_type)?; if !expected_key_type.admits_type(&StacksEpochId::Epoch21, &key_type)? { - Err(StaticCheckError::new(CheckErrorKind::TypeError( + Err(StaticCheckError::new(StaticCheckErrorKind::TypeError( Box::new(expected_key_type.clone()), Box::new(key_type), ))) @@ -104,7 +109,9 @@ fn check_set_or_insert_entry( ) -> Result { check_arguments_at_least(3, args)?; - let map_name = args[0].match_atom().ok_or(CheckErrorKind::BadMapName)?; + let map_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadMapName)?; let key_type = checker.type_check(&args[1], context)?; let value_type = checker.type_check(&args[2], context)?; @@ -112,7 +119,7 @@ fn check_set_or_insert_entry( let (expected_key_type, expected_value_type) = checker .contract_context .get_map_type(map_name) - .ok_or(CheckErrorKind::NoSuchMap(map_name.to_string()))?; + .ok_or(StaticCheckErrorKind::NoSuchMap(map_name.to_string()))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -129,12 +136,12 @@ fn check_set_or_insert_entry( analysis_typecheck_cost(&mut checker.cost_track, expected_value_type, &value_type)?; if !expected_key_type.admits_type(&StacksEpochId::Epoch21, &key_type)? { - Err(StaticCheckError::new(CheckErrorKind::TypeError( + Err(StaticCheckError::new(StaticCheckErrorKind::TypeError( Box::new(expected_key_type.clone()), Box::new(key_type), ))) } else if !expected_value_type.admits_type(&StacksEpochId::Epoch21, &value_type)? { - Err(StaticCheckError::new(CheckErrorKind::TypeError( + Err(StaticCheckError::new(StaticCheckErrorKind::TypeError( Box::new(expected_value_type.clone()), Box::new(value_type), ))) diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs index d91f0d7e781..b726967bd21 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs @@ -20,7 +20,7 @@ use super::{ check_argument_count, check_arguments_at_least, check_arguments_at_most, compute_typecheck_cost, no_type, TypeChecker, TypingContext, }; -use crate::vm::analysis::errors::{CheckErrorKind, StaticCheckError, SyntaxBindingErrorType}; +use crate::vm::analysis::errors::{StaticCheckError, StaticCheckErrorKind, SyntaxBindingErrorType}; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, runtime_cost, CostErrors, CostTracker}; use crate::vm::diagnostic::DiagnosableError; @@ -69,14 +69,17 @@ fn check_special_list_cons( for arg in args.iter() { // don't use map here, since type_check has side-effects. let checked = checker.type_check(arg, context)?; - let cost = checked.type_size().and_then(|ty_size| { - checker - .compute_cost( - ClarityCostFunction::AnalysisListItemsCheck, - &[ty_size.into()], - ) - .map_err(CheckErrorKind::from) - }); + let cost = checked + .type_size() + .map_err(StaticCheckErrorKind::from) + .and_then(|ty_size| { + checker + .compute_cost( + ClarityCostFunction::AnalysisListItemsCheck, + &[ty_size.into()], + ) + .map_err(StaticCheckErrorKind::from) + }); costs.push(cost); if let Some(cur_size) = entries_size { @@ -96,7 +99,7 @@ fn check_special_list_cons( checker.add_cost(cost?)?; } if entries_size.is_none() { - return Err(CheckErrorKind::ValueTooLarge.into()); + return Err(StaticCheckErrorKind::ValueTooLarge.into()); } let typed_args = result; TypeSignature::parent_list_type(&typed_args) @@ -155,10 +158,12 @@ fn inner_handle_tuple_get( let return_type = tuple_type_sig .field_type(field_to_get) - .ok_or(StaticCheckError::new(CheckErrorKind::NoSuchTupleField( - field_to_get.to_string(), - tuple_type_sig.clone(), - )))? + .ok_or(StaticCheckError::new( + StaticCheckErrorKind::NoSuchTupleField( + field_to_get.to_string(), + tuple_type_sig.clone(), + ), + ))? .clone(); Ok(return_type) } @@ -172,7 +177,7 @@ fn check_special_get( let field_to_get = args[0] .match_atom() - .ok_or(CheckErrorKind::BadTupleFieldName)?; + .ok_or(StaticCheckErrorKind::BadTupleFieldName)?; let argument_type = checker.type_check(&args[1], context)?; @@ -184,10 +189,10 @@ fn check_special_get( let option_type = TypeSignature::new_option(inner_type)?; Ok(option_type) } else { - Err(CheckErrorKind::ExpectedTuple(value_type_sig).into()) + Err(StaticCheckErrorKind::ExpectedTuple(value_type_sig).into()) } } else { - Err(CheckErrorKind::ExpectedTuple(Box::new(argument_type)).into()) + Err(StaticCheckErrorKind::ExpectedTuple(Box::new(argument_type)).into()) } } @@ -201,13 +206,13 @@ fn check_special_merge( let res = checker.type_check(&args[0], context)?; let mut base = match res { TypeSignature::TupleType(tuple_sig) => Ok(tuple_sig), - _ => Err(CheckErrorKind::ExpectedTuple(Box::new(res.clone()))), + _ => Err(StaticCheckErrorKind::ExpectedTuple(Box::new(res.clone()))), }?; let res = checker.type_check(&args[1], context)?; let mut update = match res { TypeSignature::TupleType(tuple_sig) => Ok(tuple_sig), - _ => Err(CheckErrorKind::ExpectedTuple(Box::new(res.clone()))), + _ => Err(StaticCheckErrorKind::ExpectedTuple(Box::new(res.clone()))), }?; runtime_cost( ClarityCostFunction::AnalysisCheckTupleMerge, @@ -255,7 +260,7 @@ pub fn check_special_tuple_cons( .saturating_add(var_type.size()?); tuple_type_data.push((var_name.clone(), var_type)); } else { - cons_error = Err(CheckErrorKind::BadTupleConstruction(format!( + cons_error = Err(StaticCheckErrorKind::BadTupleConstruction(format!( "type size of {type_size} bytes exceeds maximum of {MAX_VALUE_SIZE} bytes" ))); } @@ -265,8 +270,9 @@ pub fn check_special_tuple_cons( )?; cons_error?; - let tuple_signature = TupleTypeSignature::try_from(tuple_type_data) - .map_err(|e| CheckErrorKind::BadTupleConstruction(e.message()))?; + let tuple_signature = TupleTypeSignature::try_from(tuple_type_data).map_err(|e| { + StaticCheckErrorKind::BadTupleConstruction(StaticCheckErrorKind::from(e).message()) + })?; Ok(TypeSignature::TupleType(tuple_signature)) } @@ -281,7 +287,7 @@ fn check_special_let( let binding_list = args[0] .match_list() - .ok_or(StaticCheckError::new(CheckErrorKind::BadLetSyntax))?; + .ok_or(StaticCheckError::new(StaticCheckErrorKind::BadLetSyntax))?; let mut out_context = context.extend()?; @@ -294,9 +300,9 @@ fn check_special_let( |var_name, var_sexp| { checker.contract_context.check_name_used(var_name)?; if out_context.lookup_variable_type(var_name).is_some() { - return Err(StaticCheckError::new(CheckErrorKind::NameAlreadyUsed( - var_name.to_string(), - ))); + return Err(StaticCheckError::new( + StaticCheckErrorKind::NameAlreadyUsed(var_name.to_string()), + )); } let typed_result = checker.type_check(var_sexp, &out_context)?; @@ -336,14 +342,14 @@ fn check_special_fetch_var( let var_name = args[0] .match_atom() - .ok_or(StaticCheckError::new(CheckErrorKind::BadMapName))?; + .ok_or(StaticCheckError::new(StaticCheckErrorKind::BadMapName))?; let value_type = checker .contract_context .get_persisted_variable_type(var_name) - .ok_or(StaticCheckError::new(CheckErrorKind::NoSuchDataVariable( - var_name.to_string(), - )))?; + .ok_or(StaticCheckError::new( + StaticCheckErrorKind::NoSuchDataVariable(var_name.to_string()), + ))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -361,14 +367,18 @@ fn check_special_set_var( ) -> Result { check_arguments_at_least(2, args)?; - let var_name = args[0].match_atom().ok_or(CheckErrorKind::BadMapName)?; + let var_name = args[0] + .match_atom() + .ok_or(StaticCheckErrorKind::BadMapName)?; let value_type = checker.type_check(&args[1], context)?; let expected_value_type = checker .contract_context .get_persisted_variable_type(var_name) - .ok_or(CheckErrorKind::NoSuchDataVariable(var_name.to_string()))?; + .ok_or(StaticCheckErrorKind::NoSuchDataVariable( + var_name.to_string(), + ))?; runtime_cost( ClarityCostFunction::AnalysisTypeLookup, @@ -378,7 +388,7 @@ fn check_special_set_var( analysis_typecheck_cost(&mut checker.cost_track, &value_type, expected_value_type)?; if !expected_value_type.admits_type(&StacksEpochId::Epoch21, &value_type)? { - Err(StaticCheckError::new(CheckErrorKind::TypeError( + Err(StaticCheckError::new(StaticCheckErrorKind::TypeError( Box::new(expected_value_type.clone()), Box::new(value_type), ))) @@ -407,7 +417,9 @@ fn check_special_equals( costs.push(cost); arg_type = Some( TypeSignature::least_supertype(&StacksEpochId::Epoch21, &x_type, &cur_type) - .map_err(|_| CheckErrorKind::TypeError(Box::new(x_type), Box::new(cur_type))), + .map_err(|_| { + StaticCheckErrorKind::TypeError(Box::new(x_type), Box::new(cur_type)) + }), ); } } @@ -418,7 +430,9 @@ fn check_special_equals( // check if there was a least supertype failure. arg_type.ok_or_else(|| { - CheckErrorKind::Expects("Arg type should be set because arguments checked for >= 1".into()) + StaticCheckErrorKind::Expects( + "Arg type should be set because arguments checked for >= 1".into(), + ) })??; Ok(TypeSignature::BoolType) @@ -441,9 +455,11 @@ fn check_special_if( analysis_typecheck_cost(checker, expr1, expr2)?; TypeSignature::least_supertype(&StacksEpochId::Epoch21, expr1, expr2) + .map_err(StaticCheckErrorKind::from) .and_then(|t| t.concretize()) .map_err(|_| { - CheckErrorKind::IfArmsMustMatch(Box::new(expr1.clone()), Box::new(expr2.clone())).into() + StaticCheckErrorKind::IfArmsMustMatch(Box::new(expr1.clone()), Box::new(expr2.clone())) + .into() }) } @@ -455,7 +471,7 @@ fn check_contract_call( check_arguments_at_least(2, args)?; let func_name = args[1].match_atom().ok_or(StaticCheckError::new( - CheckErrorKind::ContractCallExpectName, + StaticCheckErrorKind::ContractCallExpectName, ))?; checker.type_map.set_type(&args[1], no_type())?; @@ -480,10 +496,12 @@ fn check_contract_call( { Ok(function) } else { - Err(StaticCheckError::new(CheckErrorKind::NoSuchPublicFunction( - contract_identifier.to_string(), - func_name.to_string(), - ))) + Err(StaticCheckError::new( + StaticCheckErrorKind::NoSuchPublicFunction( + contract_identifier.to_string(), + func_name.to_string(), + ), + )) } }?; @@ -503,7 +521,7 @@ fn check_contract_call( let trait_id = match context.lookup_trait_reference_type(trait_instance) { Some(trait_id) => trait_id, _ => { - return Err(CheckErrorKind::TraitReferenceUnknown( + return Err(StaticCheckErrorKind::TraitReferenceUnknown( trait_instance.to_string(), ) .into()); @@ -513,15 +531,14 @@ fn check_contract_call( runtime_cost(ClarityCostFunction::AnalysisLookupFunction, checker, 0)?; let trait_signature = checker.contract_context.get_trait(trait_id).ok_or( - CheckErrorKind::TraitReferenceUnknown(trait_id.name.to_string()), + StaticCheckErrorKind::TraitReferenceUnknown(trait_id.name.to_string()), + )?; + let func_signature = trait_signature.get(func_name).ok_or( + StaticCheckErrorKind::TraitMethodUnknown( + trait_id.name.to_string(), + func_name.to_string(), + ), )?; - let func_signature = - trait_signature - .get(func_name) - .ok_or(CheckErrorKind::TraitMethodUnknown( - trait_id.name.to_string(), - func_name.to_string(), - ))?; runtime_cost( ClarityCostFunction::AnalysisLookupFunctionTypes, @@ -555,10 +572,12 @@ fn check_contract_call( { Ok(function) } else { - Err(StaticCheckError::new(CheckErrorKind::NoSuchPublicFunction( - contract_identifier.to_string(), - func_name.to_string(), - ))) + Err(StaticCheckError::new( + StaticCheckErrorKind::NoSuchPublicFunction( + contract_identifier.to_string(), + func_name.to_string(), + ), + )) } }?; @@ -574,7 +593,7 @@ fn check_contract_call( } Some(var_type) => { // Any other typed constant is an error - return Err(CheckErrorKind::ExpectedCallableType(Box::new( + return Err(StaticCheckErrorKind::ExpectedCallableType(Box::new( var_type.clone(), )) .into()); @@ -584,7 +603,7 @@ fn check_contract_call( let trait_id = match context.lookup_trait_reference_type(trait_instance) { Some(trait_id) => trait_id, _ => { - return Err(CheckErrorKind::TraitReferenceUnknown( + return Err(StaticCheckErrorKind::TraitReferenceUnknown( trait_instance.to_string(), ) .into()); @@ -594,10 +613,10 @@ fn check_contract_call( runtime_cost(ClarityCostFunction::AnalysisLookupFunction, checker, 0)?; let trait_signature = checker.contract_context.get_trait(trait_id).ok_or( - CheckErrorKind::TraitReferenceUnknown(trait_id.name.to_string()), + StaticCheckErrorKind::TraitReferenceUnknown(trait_id.name.to_string()), )?; let func_signature = trait_signature.get(func_name).ok_or( - CheckErrorKind::TraitMethodUnknown( + StaticCheckErrorKind::TraitMethodUnknown( trait_id.name.to_string(), func_name.to_string(), ), @@ -616,7 +635,7 @@ fn check_contract_call( } _ => { return Err(StaticCheckError::new( - CheckErrorKind::ContractCallExpectName, + StaticCheckErrorKind::ContractCallExpectName, )) } }; @@ -640,14 +659,18 @@ fn check_contract_of( SymbolicExpressionType::Atom(trait_instance) => trait_instance, _ => { return Err(StaticCheckError::new( - CheckErrorKind::ContractOfExpectsTrait, + StaticCheckErrorKind::ContractOfExpectsTrait, )) } }; let trait_id = match context.lookup_trait_reference_type(trait_instance) { Some(trait_id) => trait_id, - _ => return Err(CheckErrorKind::TraitReferenceUnknown(trait_instance.to_string()).into()), + _ => { + return Err( + StaticCheckErrorKind::TraitReferenceUnknown(trait_instance.to_string()).into(), + ) + } }; runtime_cost(ClarityCostFunction::ContractOf, checker, 1)?; @@ -655,7 +678,7 @@ fn check_contract_of( checker .contract_context .get_trait(trait_id) - .ok_or_else(|| CheckErrorKind::TraitReferenceUnknown(trait_id.name.to_string()))?; + .ok_or_else(|| StaticCheckErrorKind::TraitReferenceUnknown(trait_id.name.to_string()))?; Ok(TypeSignature::PrincipalType) } @@ -669,7 +692,7 @@ fn check_principal_of( checker.type_check_expects(&args[0], context, &TypeSignature::BUFFER_33)?; Ok( TypeSignature::new_response(TypeSignature::PrincipalType, TypeSignature::UIntType) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, ) } @@ -701,13 +724,13 @@ fn check_principal_construct( ("error_code".into(), TypeSignature::UIntType), ( "value".into(), - TypeSignature::new_option(TypeSignature::PrincipalType).map_err(|_| CheckErrorKind::Expects("FATAL: failed to create (optional principal) type signature".into()))?, + TypeSignature::new_option(TypeSignature::PrincipalType).map_err(|_| StaticCheckErrorKind::Expects("FATAL: failed to create (optional principal) type signature".into()))?, ), ]) - .map_err(|_| CheckErrorKind::Expects("FAIL: PrincipalConstruct failed to initialize type signature".into()))? + .map_err(|_| StaticCheckErrorKind::Expects("FAIL: PrincipalConstruct failed to initialize type signature".into()))? .into() ) - .map_err(|_| CheckErrorKind::Expects("FATAL: failed to create `(response principal { error_code: uint, principal: (optional principal) })` type signature".into()))? + .map_err(|_| StaticCheckErrorKind::Expects("FATAL: failed to create `(response principal { error_code: uint, principal: (optional principal) })` type signature".into()))? ) } @@ -721,7 +744,7 @@ fn check_secp256k1_recover( checker.type_check_expects(&args[1], context, &TypeSignature::BUFFER_65)?; Ok( TypeSignature::new_response(TypeSignature::BUFFER_33, TypeSignature::UIntType) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, ) } @@ -745,13 +768,13 @@ fn check_get_block_info( check_arguments_at_least(2, args)?; let block_info_prop_str = args[0].match_atom().ok_or(StaticCheckError::new( - CheckErrorKind::GetBlockInfoExpectPropertyName, + StaticCheckErrorKind::GetBlockInfoExpectPropertyName, ))?; let block_info_prop = BlockInfoProperty::lookup_by_name_at_version(block_info_prop_str, &checker.clarity_version) .ok_or(StaticCheckError::new( - CheckErrorKind::NoSuchBlockInfoProperty(block_info_prop_str.to_string()), + StaticCheckErrorKind::NoSuchBlockInfoProperty(block_info_prop_str.to_string()), ))?; checker.type_check_expects(&args[1], context, &TypeSignature::UIntType)?; @@ -760,8 +783,8 @@ fn check_get_block_info( } // # Errors -// - `CheckErrorKind::GetBurnBlockInfoExpectPropertyName` when `args[0]` is not a valid `ClarityName`. -// - `CheckErrorKind::NoSuchBlockInfoProperty` when `args[0]` does not name a `BurnBlockInfoProperty`. +// - `StaticCheckErrorKind::GetBurnBlockInfoExpectPropertyName` when `args[0]` is not a valid `ClarityName`. +// - `StaticCheckErrorKind::NoSuchBlockInfoProperty` when `args[0]` does not name a `BurnBlockInfoProperty`. fn check_get_burn_block_info( checker: &mut TypeChecker, args: &[SymbolicExpression], @@ -770,19 +793,19 @@ fn check_get_burn_block_info( check_argument_count(2, args)?; let block_info_prop_str = args[0].match_atom().ok_or(StaticCheckError::new( - CheckErrorKind::GetBurnBlockInfoExpectPropertyName, + StaticCheckErrorKind::GetBurnBlockInfoExpectPropertyName, ))?; let block_info_prop = BurnBlockInfoProperty::lookup_by_name(block_info_prop_str).ok_or(StaticCheckError::new( - CheckErrorKind::NoSuchBlockInfoProperty(block_info_prop_str.to_string()), + StaticCheckErrorKind::NoSuchBlockInfoProperty(block_info_prop_str.to_string()), ))?; checker.type_check_expects(&args[1], context, &TypeSignature::UIntType)?; Ok(TypeSignature::new_option( block_info_prop.type_result().map_err(|_| { - CheckErrorKind::Expects("FAILED to type valid burn info property".into()) + StaticCheckErrorKind::Expects("FAILED to type valid burn info property".into()) })?, )?) } @@ -795,11 +818,11 @@ fn check_get_stacks_block_info( check_argument_count(2, args)?; let block_info_prop_str = args[0].match_atom().ok_or(StaticCheckError::new( - CheckErrorKind::GetStacksBlockInfoExpectPropertyName, + StaticCheckErrorKind::GetStacksBlockInfoExpectPropertyName, ))?; let block_info_prop = StacksBlockInfoProperty::lookup_by_name(block_info_prop_str).ok_or( - StaticCheckError::new(CheckErrorKind::NoSuchStacksBlockInfoProperty( + StaticCheckError::new(StaticCheckErrorKind::NoSuchStacksBlockInfoProperty( block_info_prop_str.to_string(), )), )?; @@ -817,12 +840,12 @@ fn check_get_tenure_info( check_argument_count(2, args)?; let block_info_prop_str = args[0].match_atom().ok_or(StaticCheckError::new( - CheckErrorKind::GetTenureInfoExpectPropertyName, + StaticCheckErrorKind::GetTenureInfoExpectPropertyName, ))?; let block_info_prop = TenureInfoProperty::lookup_by_name(block_info_prop_str).ok_or(StaticCheckError::new( - CheckErrorKind::NoSuchTenureInfoProperty(block_info_prop_str.to_string()), + StaticCheckErrorKind::NoSuchTenureInfoProperty(block_info_prop_str.to_string()), ))?; checker.type_check_expects(&args[1], context, &TypeSignature::UIntType)?; @@ -852,7 +875,7 @@ impl TypedNativeFunction { pub fn type_native_function( function: &NativeFunctions, - ) -> Result { + ) -> Result { use self::TypedNativeFunction::{Simple, Special}; use crate::vm::functions::NativeFunctions::*; let out = match function { @@ -881,7 +904,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::IntType, ClarityName::try_from("value".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -892,7 +915,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::UIntType, ClarityName::try_from("value".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -903,7 +926,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::PrincipalType, ClarityName::try_from("value".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -914,11 +937,12 @@ impl TypedNativeFunction { Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction { args: vec![FunctionArg::new( TypeSignature::SequenceType(SequenceSubtype::BufferType( - BufferLength::try_from(16_u32) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + BufferLength::try_from(16_u32).map_err(|_| { + StaticCheckErrorKind::Expects("Bad constructor".into()) + })?, )), ClarityName::try_from("value".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -930,11 +954,12 @@ impl TypedNativeFunction { Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction { args: vec![FunctionArg::new( TypeSignature::SequenceType(SequenceSubtype::BufferType( - BufferLength::try_from(16_u32) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + BufferLength::try_from(16_u32).map_err(|_| { + StaticCheckErrorKind::Expects("Bad constructor".into()) + })?, )), ClarityName::try_from("value".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -970,7 +995,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::BoolType, ClarityName::try_from("value".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -1023,7 +1048,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::PrincipalType, ClarityName::try_from("owner".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -1035,7 +1060,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::PrincipalType, ClarityName::try_from("principal".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -1043,7 +1068,8 @@ impl TypedNativeFunction { returns: { /// The return type of `principal-destruct` is a Response, in which the success /// and error types are the same. - fn parse_principal_basic_type() -> Result { + fn parse_principal_basic_type( + ) -> Result { TupleTypeSignature::try_from(vec![ ("version".into(), TypeSignature::BUFFER_1), ("hash-bytes".into(), TypeSignature::BUFFER_20), @@ -1052,11 +1078,13 @@ impl TypedNativeFunction { TypeSignature::new_option( TypeSignature::CONTRACT_NAME_STRING_ASCII_MAX, ) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| { + StaticCheckErrorKind::Expects("Bad constructor".into()) + })?, ), ]) .map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: PrincipalDestruct failed to initialize type signature" .into(), ) @@ -1072,7 +1100,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::PrincipalType, ClarityName::try_from("owner".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -1083,7 +1111,7 @@ impl TypedNativeFunction { ("unlock-height".into(), TypeSignature::UIntType), ]) .map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: StxGetAccount failed to initialize type signature".into(), ) })? @@ -1094,7 +1122,7 @@ impl TypedNativeFunction { FunctionArg::new( TypeSignature::UIntType, ClarityName::try_from("amount".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -1102,7 +1130,7 @@ impl TypedNativeFunction { FunctionArg::new( TypeSignature::PrincipalType, ClarityName::try_from("sender".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -1112,7 +1140,7 @@ impl TypedNativeFunction { TypeSignature::BoolType, TypeSignature::UIntType, ) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, }))), StxTransfer => Special(SpecialNativeFunction(&assets::check_special_stx_transfer)), StxTransferMemo => Special(SpecialNativeFunction( @@ -1195,7 +1223,7 @@ impl TypedNativeFunction { args: vec![FunctionArg::new( TypeSignature::PrincipalType, ClarityName::try_from("contract".to_owned()).map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: ClarityName failed to accept default arg name".into(), ) })?, @@ -1204,7 +1232,7 @@ impl TypedNativeFunction { TypeSignature::BUFFER_32, TypeSignature::UIntType, ) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, }))), ToAscii => Simple(SimpleNativeFunction(FunctionType::UnionArgs( vec![ @@ -1220,7 +1248,7 @@ impl TypedNativeFunction { TypeSignature::UIntType, ) .map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FATAL: Legal Clarity response type marked invalid".into(), ) })?, diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs index b4f01b196c7..57406396d71 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs @@ -19,8 +19,8 @@ use clarity_types::types::TypeSignature; use stacks_common::types::StacksEpochId; use super::{ - check_argument_count, check_arguments_at_least, no_type, CheckErrorKind, StaticCheckError, - TypeChecker, + check_argument_count, check_arguments_at_least, no_type, StaticCheckError, + StaticCheckErrorKind, TypeChecker, }; use crate::vm::analysis::type_checker::contexts::TypingContext; use crate::vm::costs::cost_functions::ClarityCostFunction; @@ -83,7 +83,7 @@ pub fn check_special_is_response( if let TypeSignature::ResponseType(_types) = input { Ok(TypeSignature::BoolType) } else { - Err(CheckErrorKind::ExpectedResponseType(Box::new(input.clone())).into()) + Err(StaticCheckErrorKind::ExpectedResponseType(Box::new(input.clone())).into()) } } @@ -101,7 +101,7 @@ pub fn check_special_is_optional( if let TypeSignature::OptionalType(_type) = input { Ok(TypeSignature::BoolType) } else { - Err(CheckErrorKind::ExpectedOptionalType(Box::new(input.clone())).into()) + Err(StaticCheckErrorKind::ExpectedOptionalType(Box::new(input.clone())).into()) } } @@ -121,12 +121,15 @@ pub fn check_special_default_to( let contained_type = *input_type; TypeSignature::least_supertype(&StacksEpochId::Epoch21, &default, &contained_type).map_err( |_| { - CheckErrorKind::DefaultTypesMustMatch(Box::new(default), Box::new(contained_type)) - .into() + StaticCheckErrorKind::DefaultTypesMustMatch( + Box::new(default), + Box::new(contained_type), + ) + .into() }, ) } else { - Err(CheckErrorKind::ExpectedOptionalType(Box::new(input)).into()) + Err(StaticCheckErrorKind::ExpectedOptionalType(Box::new(input)).into()) } } @@ -154,7 +157,7 @@ fn inner_unwrap( match input { TypeSignature::OptionalType(input_type) => { if input_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseOkType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseOkType.into()) } else { Ok(*input_type) } @@ -162,12 +165,12 @@ fn inner_unwrap( TypeSignature::ResponseType(response_type) => { let ok_type = response_type.0; if ok_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseOkType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseOkType.into()) } else { Ok(ok_type) } } - _ => Err(CheckErrorKind::ExpectedOptionalOrResponseType(Box::new(input)).into()), + _ => Err(StaticCheckErrorKind::ExpectedOptionalOrResponseType(Box::new(input)).into()), } } @@ -180,12 +183,12 @@ fn inner_unwrap_err( if let TypeSignature::ResponseType(response_type) = input { let err_type = response_type.1; if err_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseErrType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseErrType.into()) } else { Ok(err_type) } } else { - Err(CheckErrorKind::ExpectedResponseType(Box::new(input)).into()) + Err(StaticCheckErrorKind::ExpectedResponseType(Box::new(input)).into()) } } @@ -233,7 +236,7 @@ pub fn check_special_try_ret( match input { TypeSignature::OptionalType(input_type) => { if input_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseOkType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseOkType.into()) } else { checker.track_return_type(TypeSignature::new_option(TypeSignature::NoType)?)?; Ok(*input_type) @@ -242,9 +245,9 @@ pub fn check_special_try_ret( TypeSignature::ResponseType(response_type) => { let (ok_type, err_type) = *response_type; if ok_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseOkType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseOkType.into()) } else if err_type.is_no_type() { - Err(CheckErrorKind::CouldNotDetermineResponseErrType.into()) + Err(StaticCheckErrorKind::CouldNotDetermineResponseErrType.into()) } else { checker.track_return_type(TypeSignature::new_response( TypeSignature::NoType, @@ -253,7 +256,7 @@ pub fn check_special_try_ret( Ok(ok_type) } } - _ => Err(CheckErrorKind::ExpectedOptionalOrResponseType(Box::new(input)).into()), + _ => Err(StaticCheckErrorKind::ExpectedOptionalOrResponseType(Box::new(input)).into()), } } @@ -306,7 +309,7 @@ fn eval_with_new_binding( checker.contract_context.check_name_used(&bind_name)?; if inner_context.lookup_variable_type(&bind_name).is_some() { - return Err(CheckErrorKind::NameAlreadyUsed(bind_name.into()).into()); + return Err(StaticCheckErrorKind::NameAlreadyUsed(bind_name.into()).into()); } inner_context.add_variable_type(bind_name, bind_type, checker.clarity_version); @@ -325,22 +328,22 @@ fn check_special_match_opt( context: &TypingContext, ) -> Result { if args.len() != 3 { - Err(CheckErrorKind::BadMatchOptionSyntax(Box::new( - CheckErrorKind::IncorrectArgumentCount(4, args.len() + 1), + Err(StaticCheckErrorKind::BadMatchOptionSyntax(Box::new( + StaticCheckErrorKind::IncorrectArgumentCount(4, args.len() + 1), )))?; } let bind_name = args[0] .match_atom() .ok_or_else(|| { - CheckErrorKind::BadMatchOptionSyntax(Box::new(CheckErrorKind::ExpectedName)) + StaticCheckErrorKind::BadMatchOptionSyntax(Box::new(StaticCheckErrorKind::ExpectedName)) })? .clone(); let some_branch = &args[1]; let none_branch = &args[2]; if option_type.is_no_type() { - return Err(CheckErrorKind::CouldNotDetermineMatchTypes.into()); + return Err(StaticCheckErrorKind::CouldNotDetermineMatchTypes.into()); } let some_branch_type = @@ -355,8 +358,11 @@ fn check_special_match_opt( &none_branch_type, ) .map_err(|_| { - CheckErrorKind::MatchArmsMustMatch(Box::new(some_branch_type), Box::new(none_branch_type)) - .into() + StaticCheckErrorKind::MatchArmsMustMatch( + Box::new(some_branch_type), + Box::new(none_branch_type), + ) + .into() }) } @@ -367,22 +373,26 @@ fn check_special_match_resp( context: &TypingContext, ) -> Result { if args.len() != 4 { - Err(CheckErrorKind::BadMatchResponseSyntax(Box::new( - CheckErrorKind::IncorrectArgumentCount(5, args.len() + 1), + Err(StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::IncorrectArgumentCount(5, args.len() + 1), )))?; } let ok_bind_name = args[0] .match_atom() .ok_or_else(|| { - CheckErrorKind::BadMatchResponseSyntax(Box::new(CheckErrorKind::ExpectedName)) + StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::ExpectedName, + )) })? .clone(); let ok_branch = &args[1]; let err_bind_name = args[2] .match_atom() .ok_or_else(|| { - CheckErrorKind::BadMatchResponseSyntax(Box::new(CheckErrorKind::ExpectedName)) + StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::ExpectedName, + )) })? .clone(); let err_branch = &args[3]; @@ -390,7 +400,7 @@ fn check_special_match_resp( let (ok_type, err_type) = resp_type; if ok_type.is_no_type() || err_type.is_no_type() { - return Err(CheckErrorKind::CouldNotDetermineMatchTypes.into()); + return Err(StaticCheckErrorKind::CouldNotDetermineMatchTypes.into()); } let ok_branch_type = eval_with_new_binding(ok_branch, ok_bind_name, ok_type, checker, context)?; @@ -401,8 +411,11 @@ fn check_special_match_resp( TypeSignature::least_supertype(&StacksEpochId::Epoch21, &ok_branch_type, &err_branch_type) .map_err(|_| { - CheckErrorKind::MatchArmsMustMatch(Box::new(ok_branch_type), Box::new(err_branch_type)) - .into() + StaticCheckErrorKind::MatchArmsMustMatch( + Box::new(ok_branch_type), + Box::new(err_branch_type), + ) + .into() }) } @@ -422,6 +435,6 @@ pub fn check_special_match( TypeSignature::ResponseType(resp_type) => { check_special_match_resp(*resp_type, checker, &args[1..], context) } - _ => Err(CheckErrorKind::BadMatchInput(Box::new(input)).into()), + _ => Err(StaticCheckErrorKind::BadMatchInput(Box::new(input)).into()), } } diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs index c2e162dae25..ab81b4a5d22 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs @@ -18,8 +18,8 @@ use stacks_common::types::StacksEpochId; use super::{SimpleNativeFunction, TypedNativeFunction}; use crate::vm::analysis::type_checker::v2_1::{ - check_argument_count, check_arguments_at_least, CheckErrorKind, StaticCheckError, TypeChecker, - TypingContext, + check_argument_count, check_arguments_at_least, StaticCheckError, StaticCheckErrorKind, + TypeChecker, TypingContext, }; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, runtime_cost, CostTracker}; @@ -44,14 +44,15 @@ fn get_simple_native_or_user_define( { Ok(function_type) } else { - Err( - CheckErrorKind::IllegalOrUnknownFunctionApplication(function_name.to_string()) - .into(), + Err(StaticCheckErrorKind::IllegalOrUnknownFunctionApplication( + function_name.to_string(), ) + .into()) } } else { checker.get_function_type(function_name).ok_or( - CheckErrorKind::IllegalOrUnknownFunctionApplication(function_name.to_string()).into(), + StaticCheckErrorKind::IllegalOrUnknownFunctionApplication(function_name.to_string()) + .into(), ) } } @@ -65,7 +66,7 @@ pub fn check_special_map( let function_name = args[0] .match_atom() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; // we will only lookup native or defined functions here. // you _cannot_ map a special function. let function_type = get_simple_native_or_user_define(function_name, checker)?; @@ -107,7 +108,7 @@ pub fn check_special_map( // However that could lead to confusions when combining certain types: // ex: (map concat (list "hello " "hi ") "world") would fail, because // strings are handled as sequences. - return Err(CheckErrorKind::ExpectedSequence(Box::new(argument_type)).into()); + return Err(StaticCheckErrorKind::ExpectedSequence(Box::new(argument_type)).into()); } }; @@ -137,8 +138,8 @@ pub fn check_special_map( } if let Err(mut check_error) = check_result { - if let CheckErrorKind::IncorrectArgumentCount(expected, _actual) = *check_error.err { - check_error.err = Box::new(CheckErrorKind::IncorrectArgumentCount( + if let StaticCheckErrorKind::IncorrectArgumentCount(expected, _actual) = *check_error.err { + check_error.err = Box::new(StaticCheckErrorKind::IncorrectArgumentCount( expected, args.len().saturating_sub(1), )); @@ -159,7 +160,7 @@ pub fn check_special_map( context.clarity_version, )?; TypeSignature::list_of(mapped_type, min_args) - .map_err(|_| CheckErrorKind::ConstructedListTooLarge.into()) + .map_err(|_| StaticCheckErrorKind::ConstructedListTooLarge.into()) } pub fn check_special_filter( @@ -171,7 +172,7 @@ pub fn check_special_filter( let function_name = args[0] .match_atom() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; // we will only lookup native or defined functions here. // you _cannot_ map a special function. let function_type = get_simple_native_or_user_define(function_name, checker)?; @@ -182,7 +183,7 @@ pub fn check_special_filter( { let input_type = match argument_type { TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new( + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new( argument_type.clone(), ))), }?; @@ -195,7 +196,7 @@ pub fn check_special_filter( )?; if TypeSignature::BoolType != filter_type { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BoolType), Box::new(filter_type), ) @@ -215,7 +216,7 @@ pub fn check_special_fold( let function_name = args[0] .match_atom() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; // we will only lookup native or defined functions here. // you _cannot_ fold a special function. let function_type = get_simple_native_or_user_define(function_name, checker)?; @@ -225,7 +226,9 @@ pub fn check_special_fold( let input_type = match argument_type { TypeSignature::SequenceType(sequence_type) => Ok(sequence_type.unit_type()), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new(argument_type))), + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new( + argument_type, + ))), }?; let initial_value_type = checker.type_check(&args[2], context)?; @@ -283,29 +286,29 @@ pub fn check_special_concat( )?; let new_len = lhs_max_len .checked_add(rhs_max_len) - .ok_or(CheckErrorKind::MaxLengthOverflow)?; + .ok_or(StaticCheckErrorKind::MaxLengthOverflow)?; TypeSignature::list_of(list_entry_type, new_len)? } (BufferType(lhs_len), BufferType(rhs_len)) => { let size: u32 = u32::from(lhs_len) .checked_add(u32::from(rhs_len)) - .ok_or(CheckErrorKind::MaxLengthOverflow)?; + .ok_or(StaticCheckErrorKind::MaxLengthOverflow)?; TypeSignature::SequenceType(BufferType(size.try_into()?)) } (StringType(ASCII(lhs_len)), StringType(ASCII(rhs_len))) => { let size: u32 = u32::from(lhs_len) .checked_add(u32::from(rhs_len)) - .ok_or(CheckErrorKind::MaxLengthOverflow)?; + .ok_or(StaticCheckErrorKind::MaxLengthOverflow)?; TypeSignature::SequenceType(StringType(ASCII(size.try_into()?))) } (StringType(UTF8(lhs_len)), StringType(UTF8(rhs_len))) => { let size: u32 = u32::from(lhs_len) .checked_add(u32::from(rhs_len)) - .ok_or(CheckErrorKind::MaxLengthOverflow)?; + .ok_or(StaticCheckErrorKind::MaxLengthOverflow)?; TypeSignature::SequenceType(StringType(UTF8(size.try_into()?))) } (_, _) => { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(lhs_type.clone()), Box::new(rhs_type.clone()), ) @@ -313,7 +316,7 @@ pub fn check_special_concat( } } } - _ => return Err(CheckErrorKind::ExpectedSequence(Box::new(lhs_type.clone())).into()), + _ => return Err(StaticCheckErrorKind::ExpectedSequence(Box::new(lhs_type.clone())).into()), }; Ok(res) } @@ -342,11 +345,11 @@ pub fn check_special_append( )?; let new_len = lhs_max_len .checked_add(1) - .ok_or(CheckErrorKind::MaxLengthOverflow)?; + .ok_or(StaticCheckErrorKind::MaxLengthOverflow)?; let return_type = TypeSignature::list_of(list_entry_type, new_len)?; Ok(return_type) } - _ => Err(CheckErrorKind::ExpectedListApplication.into()), + _ => Err(StaticCheckErrorKind::ExpectedListApplication.into()), } } @@ -361,7 +364,7 @@ pub fn check_special_as_max_len( SymbolicExpressionType::LiteralValue(Value::UInt(expected_len)) => expected_len, _ => { let expected_len_type = checker.type_check(&args[1], context)?; - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(expected_len_type), ) @@ -378,7 +381,7 @@ pub fn check_special_as_max_len( .set_type(&args[1], TypeSignature::UIntType)?; let expected_len = - u32::try_from(expected_len).map_err(|_e| CheckErrorKind::MaxLengthOverflow)?; + u32::try_from(expected_len).map_err(|_e| StaticCheckErrorKind::MaxLengthOverflow)?; let sequence = checker.type_check(&args[0], context)?; runtime_cost(ClarityCostFunction::AnalysisIterableFunc, checker, 0)?; @@ -404,7 +407,7 @@ pub fn check_special_as_max_len( StringUTF8Length::try_from(expected_len)?, )))), )), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new(sequence)).into()), + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new(sequence)).into()), } } @@ -420,7 +423,9 @@ pub fn check_special_len( match collection_type { TypeSignature::SequenceType(_) => Ok(()), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new(collection_type))), + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new( + collection_type, + ))), }?; Ok(TypeSignature::UIntType) @@ -449,16 +454,16 @@ pub fn check_special_element_at( TypeSignature::SequenceType(StringType(ASCII(_))) => Ok(TypeSignature::OptionalType( Box::new(TypeSignature::SequenceType(StringType(ASCII( BufferLength::try_from(1u32) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, )))), )), TypeSignature::SequenceType(StringType(UTF8(_))) => Ok(TypeSignature::OptionalType( Box::new(TypeSignature::SequenceType(StringType(UTF8( StringUTF8Length::try_from(1u32) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, )))), )), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new(collection_type)).into()), + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new(collection_type)).into()), } } @@ -474,7 +479,7 @@ pub fn check_special_index_of( let expected_input_type = match list_type { TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()), - _ => Err(CheckErrorKind::ExpectedSequence(Box::new(list_type))), + _ => Err(StaticCheckErrorKind::ExpectedSequence(Box::new(list_type))), }?; checker.type_check_expects(&args[1], context, &expected_input_type)?; @@ -497,7 +502,7 @@ pub fn check_special_slice( TypeSignature::SequenceType(seq) => { TypeSignature::new_option(TypeSignature::SequenceType(seq))? } - _ => return Err(CheckErrorKind::ExpectedSequence(Box::new(seq_type)).into()), + _ => return Err(StaticCheckErrorKind::ExpectedSequence(Box::new(seq_type)).into()), }; // Check left position argument @@ -521,7 +526,7 @@ pub fn check_special_replace_at( let input_type = checker.type_check(&args[0], context)?; let seq_type = match &input_type { TypeSignature::SequenceType(seq) => seq, - _ => return Err(CheckErrorKind::ExpectedSequence(Box::new(input_type)).into()), + _ => return Err(StaticCheckErrorKind::ExpectedSequence(Box::new(input_type)).into()), }; let unit_seq = seq_type.unit_type(); // Check index argument diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs index cd2c5620c04..e8a4eeadaac 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs @@ -21,7 +21,7 @@ use rstest_reuse::{self, *}; use stacks_common::types::StacksEpochId; use super::contracts::type_check; -use crate::vm::analysis::errors::CheckErrorKind; +use crate::vm::analysis::errors::StaticCheckErrorKind; use crate::vm::ast::parse; use crate::vm::database::MemoryBackingStore; use crate::vm::tests::test_clarity_versions; @@ -173,108 +173,108 @@ fn test_bad_asset_usage() { ]; let expected = [ - CheckErrorKind::NoSuchFT("stackoos".to_string()), - CheckErrorKind::BadTokenName, - CheckErrorKind::BadTokenName, - CheckErrorKind::TypeError( + StaticCheckErrorKind::NoSuchFT("stackoos".to_string()), + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::IntType), ), - CheckErrorKind::BadTokenName, - CheckErrorKind::NoSuchNFT("stackoos".to_string()), - CheckErrorKind::TypeError( + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::NoSuchNFT("stackoos".to_string()), + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(string_ascii_type(15)), ), - CheckErrorKind::BadTokenName, - CheckErrorKind::NoSuchNFT("stackoos".to_string()), - CheckErrorKind::TypeError( + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::NoSuchNFT("stackoos".to_string()), + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(string_ascii_type(15)), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::NoSuchFT("stackoos".to_string()), - CheckErrorKind::BadTokenName, - CheckErrorKind::TypeError( + StaticCheckErrorKind::NoSuchFT("stackoos".to_string()), + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::BoolType), ), - CheckErrorKind::BadTokenName, - CheckErrorKind::NoSuchNFT("stackoos".to_string()), - CheckErrorKind::TypeError( + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::NoSuchNFT("stackoos".to_string()), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::BadTokenName, - CheckErrorKind::TypeError( + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::TypeError( Box::new(string_ascii_type(10)), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::NoSuchFT("stackoos".to_string()), - CheckErrorKind::BadTokenName, - CheckErrorKind::TypeError( + StaticCheckErrorKind::NoSuchFT("stackoos".to_string()), + StaticCheckErrorKind::BadTokenName, + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::BoolType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::BoolType), ), - CheckErrorKind::DefineNFTBadSignature, - CheckErrorKind::TypeError( + StaticCheckErrorKind::DefineNFTBadSignature, + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::IntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::IntType), ), - CheckErrorKind::NoSuchFT("stackoos".to_string()), - CheckErrorKind::NoSuchFT("stackoos".to_string()), - CheckErrorKind::TypeError( + StaticCheckErrorKind::NoSuchFT("stackoos".to_string()), + StaticCheckErrorKind::NoSuchFT("stackoos".to_string()), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::IntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::IntType), ), diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs index 18d3ae19d52..1afb27a6a42 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs @@ -21,11 +21,10 @@ use serde_json; use stacks_common::types::StacksEpochId; use crate::vm::analysis::contract_interface_builder::build_contract_interface; -use crate::vm::analysis::errors::CheckErrorKind; use crate::vm::analysis::type_checker::v2_1::tests::mem_type_check; use crate::vm::analysis::{ mem_type_check as mem_run_analysis, run_analysis, AnalysisDatabase, ContractAnalysis, - StaticCheckError, + StaticCheckError, StaticCheckErrorKind, }; use crate::vm::ast::parse; use crate::vm::costs::LimitedCostTracker; @@ -494,7 +493,7 @@ fn test_names_tokens_contracts_bad(#[case] version: ClarityVersion, #[case] epoc let err = db .execute(|db| type_check(&names_contract_id, &mut names_contract, db, true)) .unwrap_err(); - assert!(matches!(*err.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*err.err, StaticCheckErrorKind::TypeError(_, _))); } #[test] @@ -535,12 +534,12 @@ fn test_bad_map_usage() { for contract in tests.iter() { let err = mem_type_check(contract).unwrap_err(); - assert!(matches!(*err.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*err.err, StaticCheckErrorKind::TypeError(_, _))); } assert!(matches!( *mem_type_check(unhandled_option).unwrap_err().err, - CheckErrorKind::UnionTypeError(_, _) + StaticCheckErrorKind::UnionTypeError(_, _) )); } @@ -629,7 +628,7 @@ fn test_expects() { eprintln!("unmatched_return_types returned check error: {err}"); assert!(matches!( *err.err, - CheckErrorKind::ReturnTypesMustMatch(_, _) + StaticCheckErrorKind::ReturnTypesMustMatch(_, _) )); } @@ -637,21 +636,21 @@ fn test_expects() { eprintln!("bad_default_types returned check error: {err}"); assert!(matches!( *err.err, - CheckErrorKind::DefaultTypesMustMatch(_, _) + StaticCheckErrorKind::DefaultTypesMustMatch(_, _) )); let err = mem_type_check(notype_response_type).unwrap_err(); eprintln!("notype_response_type returned check error: {err}"); assert!(matches!( *err.err, - CheckErrorKind::CouldNotDetermineResponseErrType + StaticCheckErrorKind::CouldNotDetermineResponseErrType )); let err = mem_type_check(notype_response_type_2).unwrap_err(); eprintln!("notype_response_type_2 returned check error: {err}"); assert!(matches!( *err.err, - CheckErrorKind::CouldNotDetermineResponseOkType + StaticCheckErrorKind::CouldNotDetermineResponseOkType )); } @@ -687,7 +686,7 @@ fn test_trait_to_compatible_trait() { mem_type_check(trait_to_compatible_trait).unwrap(); let err = mem_type_check_v1(trait_to_compatible_trait).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::CallableType(CallableSubtype::Trait(found_trait)), @@ -714,7 +713,7 @@ fn test_bad_principal_to_trait() { let err = mem_type_check(bad_principal_to_trait).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::PrincipalType, @@ -727,7 +726,7 @@ fn test_bad_principal_to_trait() { }; let err = mem_type_check_v1(bad_principal_to_trait).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::PrincipalType, @@ -756,7 +755,7 @@ fn test_bad_other_trait() { let err = mem_type_check(bad_other_trait).unwrap_err(); match *err.err { - CheckErrorKind::IncompatibleTrait(expected, actual) => { + StaticCheckErrorKind::IncompatibleTrait(expected, actual) => { assert_eq!(expected.name.as_str(), "trait-2"); assert_eq!(actual.name.as_str(), "trait-1"); } @@ -764,7 +763,7 @@ fn test_bad_other_trait() { }; let err = mem_type_check_v1(bad_other_trait).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, actual) => match (&*expected, &*actual) { + StaticCheckErrorKind::TypeError(expected, actual) => match (&*expected, &*actual) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::CallableType(CallableSubtype::Trait(found_trait)), @@ -797,7 +796,7 @@ fn test_embedded_trait() { mem_type_check(embedded_trait).unwrap(); let err = mem_type_check_v1(embedded_trait).unwrap_err(); match *err.err { - CheckErrorKind::TraitReferenceUnknown(name) => { + StaticCheckErrorKind::TraitReferenceUnknown(name) => { assert_eq!(name.as_str(), "contract"); } _ => panic!("Unexpected error: {err:?}"), @@ -827,7 +826,7 @@ fn test_embedded_trait_compatible() { mem_type_check(embedded_trait_compatible).unwrap(); let err = mem_type_check_v1(embedded_trait_compatible).unwrap_err(); match *err.err { - CheckErrorKind::TraitReferenceUnknown(name) => { + StaticCheckErrorKind::TraitReferenceUnknown(name) => { assert_eq!(name.as_str(), "contract"); } _ => panic!("Unexpected error: {err:?}"), @@ -860,7 +859,7 @@ fn test_bad_embedded_trait() { let err = mem_type_check(bad_embedded_trait).unwrap_err(); match *err.err { - CheckErrorKind::IncompatibleTrait(expected, actual) => { + StaticCheckErrorKind::IncompatibleTrait(expected, actual) => { assert_eq!(expected.name.as_str(), "trait-12"); assert_eq!(actual.name.as_str(), "trait-1"); } @@ -868,7 +867,7 @@ fn test_bad_embedded_trait() { }; let err = mem_type_check_v1(bad_embedded_trait).unwrap_err(); match *err.err { - CheckErrorKind::TraitReferenceUnknown(name) => { + StaticCheckErrorKind::TraitReferenceUnknown(name) => { assert_eq!(name.as_str(), "contract"); } _ => panic!("Unexpected error: {err:?}"), @@ -890,7 +889,7 @@ fn test_let_trait() { mem_type_check(let_trait).unwrap(); let err = mem_type_check_v1(let_trait).unwrap_err(); match *err.err { - CheckErrorKind::TraitReferenceUnknown(name) => { + StaticCheckErrorKind::TraitReferenceUnknown(name) => { assert_eq!(name.as_str(), "t1"); } _ => panic!("Unexpected error: {err:?}"), @@ -916,7 +915,7 @@ fn test_let3_trait() { mem_type_check(let3_trait).unwrap(); let err = mem_type_check_v1(let3_trait).unwrap_err(); match *err.err { - CheckErrorKind::TraitReferenceUnknown(name) => { + StaticCheckErrorKind::TraitReferenceUnknown(name) => { assert_eq!(name.as_str(), "t3"); } _ => panic!("Unexpected error: {err:?}"), @@ -971,7 +970,7 @@ fn test_let3_compound_trait_call() { mem_type_check(let3_compound_trait_call).unwrap(); let err = mem_type_check_v1(let3_compound_trait_call).unwrap_err(); match *err.err { - CheckErrorKind::TraitReferenceUnknown(name) => { + StaticCheckErrorKind::TraitReferenceUnknown(name) => { assert_eq!(name.as_str(), "t4"); } _ => panic!("Unexpected error: {err:?}"), @@ -995,7 +994,7 @@ fn test_trait_args_differ() { let err = mem_type_check(trait_args_differ).unwrap_err(); match *err.err { - CheckErrorKind::IncompatibleTrait(expected, actual) => { + StaticCheckErrorKind::IncompatibleTrait(expected, actual) => { assert_eq!(expected.name.as_str(), "trait-2"); assert_eq!(actual.name.as_str(), "trait-1"); } @@ -1003,7 +1002,7 @@ fn test_trait_args_differ() { }; let err = mem_type_check_v1(trait_args_differ).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::CallableType(CallableSubtype::Trait(found_trait)), @@ -1033,7 +1032,7 @@ fn test_trait_arg_counts_differ1() { let err = mem_type_check(trait_to_compatible_trait).unwrap_err(); match *err.err { - CheckErrorKind::IncompatibleTrait(expected, found) => { + StaticCheckErrorKind::IncompatibleTrait(expected, found) => { assert_eq!(expected.name.as_str(), "trait-2"); assert_eq!(found.name.as_str(), "trait-1"); } @@ -1041,7 +1040,7 @@ fn test_trait_arg_counts_differ1() { }; let err = mem_type_check_v1(trait_to_compatible_trait).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::CallableType(CallableSubtype::Trait(found_trait)), @@ -1071,7 +1070,7 @@ fn test_trait_arg_counts_differ2() { let err = mem_type_check(trait_to_compatible_trait).unwrap_err(); match *err.err { - CheckErrorKind::IncompatibleTrait(expected, found) => { + StaticCheckErrorKind::IncompatibleTrait(expected, found) => { assert_eq!(expected.name.as_str(), "trait-2"); assert_eq!(found.name.as_str(), "trait-1"); } @@ -1079,7 +1078,7 @@ fn test_trait_arg_counts_differ2() { }; let err = mem_type_check_v1(trait_to_compatible_trait).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::CallableType(CallableSubtype::Trait(found_trait)), @@ -1109,7 +1108,7 @@ fn test_trait_ret_ty_differ() { let err = mem_type_check(trait_ret_ty_differ).unwrap_err(); match *err.err { - CheckErrorKind::IncompatibleTrait(expected, actual) => { + StaticCheckErrorKind::IncompatibleTrait(expected, actual) => { assert_eq!(expected.name.as_str(), "trait-2"); assert_eq!(actual.name.as_str(), "trait-1"); } @@ -1117,7 +1116,7 @@ fn test_trait_ret_ty_differ() { }; let err = mem_type_check_v1(trait_ret_ty_differ).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::CallableType(CallableSubtype::Trait(found_trait)), @@ -1155,7 +1154,7 @@ fn test_trait_with_compatible_trait_arg() { mem_type_check(trait_with_compatible_trait_arg).unwrap(); let err = mem_type_check_v1(trait_with_compatible_trait_arg).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::CallableType(CallableSubtype::Trait(found_trait)), @@ -1192,7 +1191,7 @@ fn test_trait_with_bad_trait_arg() { let err = mem_type_check(trait_with_bad_trait_arg).unwrap_err(); match *err.err { - CheckErrorKind::IncompatibleTrait(expected, actual) => { + StaticCheckErrorKind::IncompatibleTrait(expected, actual) => { assert_eq!(expected.name.as_str(), "trait-b"); assert_eq!(actual.name.as_str(), "trait-a"); } @@ -1200,7 +1199,7 @@ fn test_trait_with_bad_trait_arg() { }; let err = mem_type_check_v1(trait_with_bad_trait_arg).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::CallableType(CallableSubtype::Trait(found_trait)), @@ -1238,7 +1237,7 @@ fn test_trait_with_superset_trait_arg() { let err = mem_type_check(trait_with_superset_trait_arg).unwrap_err(); match *err.err { - CheckErrorKind::IncompatibleTrait(expected, actual) => { + StaticCheckErrorKind::IncompatibleTrait(expected, actual) => { assert_eq!(expected.name.as_str(), "trait-b"); assert_eq!(actual.name.as_str(), "trait-a"); } @@ -1248,7 +1247,7 @@ fn test_trait_with_superset_trait_arg() { let err = mem_type_check_v1(trait_with_superset_trait_arg).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::CallableType(CallableSubtype::Trait(found_trait)), @@ -1287,7 +1286,7 @@ fn test_trait_with_subset_trait_arg() { mem_type_check(trait_with_subset_trait_arg).unwrap(); let err = mem_type_check_v1(trait_with_subset_trait_arg).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::CallableType(CallableSubtype::Trait(found_trait)), @@ -1311,7 +1310,7 @@ fn test_trait_with_duplicate_method() { let err = mem_type_check(trait_with_duplicate_method).unwrap_err(); match *err.err { - CheckErrorKind::DefineTraitDuplicateMethod(method_name) => { + StaticCheckErrorKind::DefineTraitDuplicateMethod(method_name) => { assert_eq!(method_name.as_str(), "foo"); } _ => panic!("Unexpected error: {err:?}"), @@ -1340,7 +1339,7 @@ fn test_trait_to_subtrait_and_back() { let err = mem_type_check(trait_to_subtrait_and_back).unwrap_err(); match *err.err { - CheckErrorKind::IncompatibleTrait(expected, actual) => { + StaticCheckErrorKind::IncompatibleTrait(expected, actual) => { assert_eq!(expected.name.as_str(), "trait-2"); assert_eq!(actual.name.as_str(), "trait-1"); } @@ -1348,7 +1347,7 @@ fn test_trait_to_subtrait_and_back() { }; let err = mem_type_check_v1(trait_to_subtrait_and_back).unwrap_err(); match *err.err { - CheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { + StaticCheckErrorKind::TypeError(expected, found) => match (&*expected, &*found) { ( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait)), TypeSignature::CallableType(CallableSubtype::Trait(found_trait)), @@ -1395,7 +1394,7 @@ fn test_if_branches_with_incompatible_trait_types() { )"; let err = mem_type_check(if_branches_with_incompatible_trait_types).unwrap_err(); match *err.err { - CheckErrorKind::IfArmsMustMatch(type1, type2) => match (&*type1, &*type2) { + StaticCheckErrorKind::IfArmsMustMatch(type1, type2) => match (&*type1, &*type2) { ( TypeSignature::CallableType(CallableSubtype::Trait(trait1)), TypeSignature::CallableType(CallableSubtype::Trait(trait2)), @@ -1409,7 +1408,7 @@ fn test_if_branches_with_incompatible_trait_types() { }; let err = mem_type_check_v1(if_branches_with_incompatible_trait_types).unwrap_err(); match *err.err { - CheckErrorKind::IfArmsMustMatch(type1, type2) => match (&*type1, &*type2) { + StaticCheckErrorKind::IfArmsMustMatch(type1, type2) => match (&*type1, &*type2) { ( TypeSignature::CallableType(CallableSubtype::Trait(trait1)), TypeSignature::CallableType(CallableSubtype::Trait(trait2)), @@ -1441,7 +1440,7 @@ fn test_if_branches_with_compatible_trait_types() { let err = mem_type_check(if_branches_with_compatible_trait_types).unwrap_err(); match *err.err { - CheckErrorKind::IfArmsMustMatch(type1, type2) => match (&*type1, &*type2) { + StaticCheckErrorKind::IfArmsMustMatch(type1, type2) => match (&*type1, &*type2) { ( TypeSignature::CallableType(CallableSubtype::Trait(trait1)), TypeSignature::CallableType(CallableSubtype::Trait(trait2)), @@ -1455,7 +1454,7 @@ fn test_if_branches_with_compatible_trait_types() { }; let err = mem_type_check_v1(if_branches_with_compatible_trait_types).unwrap_err(); match *err.err { - CheckErrorKind::IfArmsMustMatch(type1, type2) => match (&*type1, &*type2) { + StaticCheckErrorKind::IfArmsMustMatch(type1, type2) => match (&*type1, &*type2) { ( TypeSignature::CallableType(CallableSubtype::Trait(trait1)), TypeSignature::CallableType(CallableSubtype::Trait(trait2)), @@ -1514,7 +1513,7 @@ fn test_traits_multi_contract(#[case] version: ClarityVersion) { match result { Ok(_) if version >= ClarityVersion::Clarity2 => (), Err(StaticCheckError { err, .. }) if version < ClarityVersion::Clarity2 => match *err { - CheckErrorKind::TraitMethodUnknown(trait_name, function) => { + StaticCheckErrorKind::TraitMethodUnknown(trait_name, function) => { assert_eq!(trait_name.as_str(), "a"); assert_eq!(function.as_str(), "do-it"); } @@ -3394,7 +3393,7 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc ( "(contract-hash? 123)", "int type", - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::IntType), )), @@ -3402,7 +3401,7 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc ( "(contract-hash? u123)", "uint type", - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::UIntType), )), @@ -3410,7 +3409,7 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc ( "(contract-hash? true)", "bool type", - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::BoolType), )), @@ -3418,7 +3417,7 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc ( "(contract-hash? 0x1234)", "buffer type", - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::SequenceType(SequenceSubtype::BufferType( BufferLength::try_from(2u32).unwrap(), @@ -3428,7 +3427,7 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc ( "(contract-hash? \"60 percent of the time, it works every time\")", "ascii string", - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::SequenceType(SequenceSubtype::StringType( StringSubtype::ASCII(BufferLength::try_from(43u32).unwrap()), @@ -3438,7 +3437,7 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc ( "(contract-hash? u\"I am serious, and don't call me Shirley.\")", "utf8 string", - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::SequenceType(SequenceSubtype::StringType( StringSubtype::UTF8(StringUTF8Length::try_from(40u32).unwrap()), @@ -3448,7 +3447,7 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc ( "(contract-hash? (list 1 2 3))", "list type", - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::SequenceType(SequenceSubtype::ListType( ListTypeData::new_list(TypeSignature::IntType, 3).unwrap(), @@ -3458,7 +3457,7 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc ( "(contract-hash? { a: 1, b: u2 })", "tuple type", - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::TupleType( vec![ @@ -3473,7 +3472,7 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc ( "(contract-hash? (some u789))", "optional type", - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::new_option(TypeSignature::UIntType).unwrap()), )), @@ -3481,7 +3480,7 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc ( "(contract-hash? (ok true))", "response type", - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new( TypeSignature::new_response(TypeSignature::BoolType, TypeSignature::NoType) @@ -3498,7 +3497,7 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc let expected = if version >= ClarityVersion::Clarity4 { clarity4_expected } else { - &Err(CheckErrorKind::UnknownFunction( + &Err(StaticCheckErrorKind::UnknownFunction( "contract-hash?".to_string(), )) }; @@ -3564,7 +3563,7 @@ fn test_to_ascii(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) ( &format!("(to-ascii? 0x{})", "ff".repeat(524285)), "oversized buffer type", - Err(CheckErrorKind::UnionTypeError( + Err(StaticCheckErrorKind::UnionTypeError( to_ascii_expected_types.clone(), Box::new(TypeSignature::SequenceType(SequenceSubtype::BufferType( BufferLength::try_from(524285u32).unwrap(), @@ -3579,7 +3578,7 @@ fn test_to_ascii(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) ( "(to-ascii? \"60 percent of the time, it works every time\")", "ascii string", - Err(CheckErrorKind::UnionTypeError( + Err(StaticCheckErrorKind::UnionTypeError( to_ascii_expected_types.clone(), Box::new(TypeSignature::SequenceType(SequenceSubtype::StringType( StringSubtype::ASCII(BufferLength::try_from(43u32).unwrap()), @@ -3589,7 +3588,7 @@ fn test_to_ascii(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) ( "(to-ascii? (list 1 2 3))", "list type", - Err(CheckErrorKind::UnionTypeError( + Err(StaticCheckErrorKind::UnionTypeError( to_ascii_expected_types.clone(), Box::new(TypeSignature::SequenceType(SequenceSubtype::ListType( ListTypeData::new_list(TypeSignature::IntType, 3).unwrap(), @@ -3599,7 +3598,7 @@ fn test_to_ascii(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) ( "(to-ascii? { a: 1, b: u2 })", "tuple type", - Err(CheckErrorKind::UnionTypeError( + Err(StaticCheckErrorKind::UnionTypeError( to_ascii_expected_types.clone(), Box::new(TypeSignature::TupleType( vec![ @@ -3614,7 +3613,7 @@ fn test_to_ascii(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) ( "(to-ascii? (some u789))", "optional type", - Err(CheckErrorKind::UnionTypeError( + Err(StaticCheckErrorKind::UnionTypeError( to_ascii_expected_types.clone(), Box::new(TypeSignature::new_option(TypeSignature::UIntType).unwrap()), )), @@ -3622,7 +3621,7 @@ fn test_to_ascii(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) ( "(to-ascii? (ok true))", "response type", - Err(CheckErrorKind::UnionTypeError( + Err(StaticCheckErrorKind::UnionTypeError( to_ascii_expected_types.clone(), Box::new( TypeSignature::new_response(TypeSignature::BoolType, TypeSignature::NoType) @@ -3639,7 +3638,9 @@ fn test_to_ascii(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) let expected = if version >= ClarityVersion::Clarity4 { clarity4_expected } else { - &Err(CheckErrorKind::UnknownFunction("to-ascii?".to_string())) + &Err(StaticCheckErrorKind::UnknownFunction( + "to-ascii?".to_string(), + )) }; assert_eq!(&actual, expected, "Failed for test case: {description}"); diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs index fb5004ca2c2..4b5cabeccac 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs @@ -21,7 +21,7 @@ use rstest::rstest; use rstest_reuse::{self, *}; use stacks_common::types::StacksEpochId; -use crate::vm::analysis::errors::{CheckErrorKind, StaticCheckError, SyntaxBindingError}; +use crate::vm::analysis::errors::{StaticCheckError, StaticCheckErrorKind, SyntaxBindingError}; use crate::vm::analysis::mem_type_check as mem_run_analysis; use crate::vm::analysis::types::ContractAnalysis; use crate::vm::ast::build_ast; @@ -90,26 +90,26 @@ fn test_from_consensus_buff() { let bad = [ ( "(from-consensus-buff?)", - CheckErrorKind::IncorrectArgumentCount(2, 0), + StaticCheckErrorKind::IncorrectArgumentCount(2, 0), ), ( "(from-consensus-buff? 0x00 0x00 0x00)", - CheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), ), ( "(from-consensus-buff? 0x00 0x00)", - CheckErrorKind::InvalidTypeDescription, + StaticCheckErrorKind::InvalidTypeDescription, ), ( "(from-consensus-buff? int u6)", - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_MAX), Box::new(TypeSignature::UIntType), ), ), ( "(from-consensus-buff? (buff 1048576) 0x00)", - CheckErrorKind::ValueTooLarge, + StaticCheckErrorKind::ValueTooLarge, ), ]; @@ -186,26 +186,26 @@ fn test_to_consensus_buff() { let bad = [ ( "(to-consensus-buff?)", - CheckErrorKind::IncorrectArgumentCount(1, 0), + StaticCheckErrorKind::IncorrectArgumentCount(1, 0), ), ( "(to-consensus-buff? 0x00 0x00)", - CheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), ), ( "(define-private (my-func (x (buff 1048576))) (to-consensus-buff? x))", - CheckErrorKind::ValueTooLarge, + StaticCheckErrorKind::ValueTooLarge, ), ( "(define-private (my-func (x (buff 1048570))) (to-consensus-buff? x))", - CheckErrorKind::ValueTooLarge, + StaticCheckErrorKind::ValueTooLarge, ), ( "(define-private (my-func (x (buff 1048567))) (to-consensus-buff? x))", - CheckErrorKind::ValueTooLarge, + StaticCheckErrorKind::ValueTooLarge, ), ]; @@ -264,10 +264,10 @@ fn test_get_block_info() { "(get-block-info? time)", ]; let bad_expected = [ - CheckErrorKind::NoSuchBlockInfoProperty("none".to_string()), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::RequiresAtLeastArguments(2, 1), + StaticCheckErrorKind::NoSuchBlockInfoProperty("none".to_string()), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::RequiresAtLeastArguments(2, 1), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -299,7 +299,7 @@ fn test_get_block_info() { } for good_test in good_v210.iter() { - if let CheckErrorKind::NoSuchBlockInfoProperty(_) = + if let StaticCheckErrorKind::NoSuchBlockInfoProperty(_) = *type_check_helper_v1(good_test).unwrap_err().err { } else { @@ -320,10 +320,10 @@ fn test_get_burn_block_info() { r#"(get-burn-block-info? header-hash "a")"#, ]; let bad_expected = [ - CheckErrorKind::NoSuchBlockInfoProperty("none".to_string()), - CheckErrorKind::IncorrectArgumentCount(2, 0), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::TypeError( + StaticCheckErrorKind::NoSuchBlockInfoProperty("none".to_string()), + StaticCheckErrorKind::IncorrectArgumentCount(2, 0), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::TypeError( Box::new(UIntType), Box::new(SequenceType(StringType(ASCII( BufferLength::try_from(1u32).expect("BufferLength::try_from failed"), @@ -364,10 +364,10 @@ fn test_define_trait(#[case] version: ClarityVersion, #[case] epoch: StacksEpoch "(define-trait)", ]; let bad_expected = [ - CheckErrorKind::InvalidTypeDescription, - CheckErrorKind::DefineTraitBadSignature, - CheckErrorKind::DefineTraitBadSignature, - CheckErrorKind::InvalidTypeDescription, + StaticCheckErrorKind::InvalidTypeDescription, + StaticCheckErrorKind::DefineTraitBadSignature, + StaticCheckErrorKind::DefineTraitBadSignature, + StaticCheckErrorKind::InvalidTypeDescription, ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { @@ -462,42 +462,42 @@ fn test_stx_ops() { "(stx-get-balance 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR)" ]; let bad_expected = [ - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(PrincipalType), Box::new(SequenceType(BufferType( BufferLength::try_from(2_u32).unwrap(), ))), ), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(3, 5), - CheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(UIntType)), - CheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(3, 5), + StaticCheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(UIntType)), + StaticCheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError( Box::new(PrincipalType), Box::new(OptionalType(Box::from(PrincipalType))), ), - CheckErrorKind::IncorrectArgumentCount(3, 4), - CheckErrorKind::TypeError( + StaticCheckErrorKind::IncorrectArgumentCount(3, 4), + StaticCheckErrorKind::TypeError( Box::new(PrincipalType), Box::new(SequenceType(BufferType( BufferLength::try_from(2_u32).unwrap(), ))), ), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(4, 5), - CheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(UIntType)), - CheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(4, 5), + StaticCheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(UIntType)), + StaticCheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError( Box::new(PrincipalType), Box::new(OptionalType(Box::from(PrincipalType))), ), - CheckErrorKind::IncorrectArgumentCount(4, 3), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), - CheckErrorKind::IncorrectArgumentCount(2, 3), - CheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), - CheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(4, 3), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::TypeError(Box::new(PrincipalType), Box::new(BoolType)), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -526,7 +526,7 @@ fn test_tx_sponsor() { ]; let bad = ["(stx-transfer? u10 tx-sponsor? 'SM2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQVX8X0G)"]; - let bad_expected = [CheckErrorKind::TypeError( + let bad_expected = [StaticCheckErrorKind::TypeError( Box::new(PrincipalType), Box::new(OptionalType(Box::from(PrincipalType))), )]; @@ -594,7 +594,7 @@ fn test_destructuring_opts(#[case] version: ClarityVersion, #[case] epoch: Stack let bad = [ ( "(unwrap-err! (some 2) 2)", - CheckErrorKind::ExpectedResponseType(Box::new(TypeSignature::from_string( + StaticCheckErrorKind::ExpectedResponseType(Box::new(TypeSignature::from_string( "(optional int)", version, epoch, @@ -602,92 +602,101 @@ fn test_destructuring_opts(#[case] version: ClarityVersion, #[case] epoch: Stack ), ( "(unwrap! (err 3) 2)", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(unwrap-err-panic (ok 3))", - CheckErrorKind::CouldNotDetermineResponseErrType, + StaticCheckErrorKind::CouldNotDetermineResponseErrType, ), ( "(unwrap-panic none)", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(define-private (foo) (if (> 1 0) none none)) (unwrap-panic (foo))", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(unwrap-panic (err 3))", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(match none inner-value (/ 1 0) (+ 1 8))", - CheckErrorKind::CouldNotDetermineMatchTypes, + StaticCheckErrorKind::CouldNotDetermineMatchTypes, ), ( "(match (ok 1) ok-val (/ ok-val 0) err-val (+ err-val 7))", - CheckErrorKind::CouldNotDetermineMatchTypes, + StaticCheckErrorKind::CouldNotDetermineMatchTypes, ), ( "(match (err 1) ok-val (/ ok-val 0) err-val (+ err-val 7))", - CheckErrorKind::CouldNotDetermineMatchTypes, + StaticCheckErrorKind::CouldNotDetermineMatchTypes, ), ( "(define-private (foo) (if (> 1 0) (ok 1) (err u8))) (match (foo) ok-val (+ 1 ok-val) err-val (/ err-val u0))", - CheckErrorKind::MatchArmsMustMatch( + StaticCheckErrorKind::MatchArmsMustMatch( Box::new(TypeSignature::IntType), Box::new(TypeSignature::UIntType), ), ), ( "(match (some 1) inner-value (+ 1 inner-value) (> 1 28))", - CheckErrorKind::MatchArmsMustMatch( + StaticCheckErrorKind::MatchArmsMustMatch( Box::new(TypeSignature::IntType), Box::new(TypeSignature::BoolType), ), ), ( "(match (some 1) inner-value (+ 1 inner-value))", - CheckErrorKind::BadMatchOptionSyntax(Box::new(CheckErrorKind::IncorrectArgumentCount( - 4, 3, - ))), + StaticCheckErrorKind::BadMatchOptionSyntax(Box::new( + StaticCheckErrorKind::IncorrectArgumentCount(4, 3), + )), ), ( "(match (ok 1) inner-value (+ 1 inner-value))", - CheckErrorKind::BadMatchResponseSyntax(Box::new( - CheckErrorKind::IncorrectArgumentCount(5, 3), + StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::IncorrectArgumentCount(5, 3), )), ), ( "(match (ok 1) 1 (+ 1 1) err-val (+ 2 err-val))", - CheckErrorKind::BadMatchResponseSyntax(Box::new(CheckErrorKind::ExpectedName)), + StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::ExpectedName, + )), ), ( "(match (ok 1) ok-val (+ 1 1) (+ 3 4) (+ 2 err-val))", - CheckErrorKind::BadMatchResponseSyntax(Box::new(CheckErrorKind::ExpectedName)), + StaticCheckErrorKind::BadMatchResponseSyntax(Box::new( + StaticCheckErrorKind::ExpectedName, + )), ), ( "(match (some 1) 2 (+ 1 1) (+ 3 4))", - CheckErrorKind::BadMatchOptionSyntax(Box::new(CheckErrorKind::ExpectedName)), + StaticCheckErrorKind::BadMatchOptionSyntax(Box::new( + StaticCheckErrorKind::ExpectedName, + )), + ), + ( + "(match)", + StaticCheckErrorKind::RequiresAtLeastArguments(1, 0), ), - ("(match)", CheckErrorKind::RequiresAtLeastArguments(1, 0)), ( "(match 1 ok-val (/ ok-val 0) err-val (+ err-val 7))", - CheckErrorKind::BadMatchInput(Box::new(TypeSignature::from_string( + StaticCheckErrorKind::BadMatchInput(Box::new(TypeSignature::from_string( "int", version, epoch, ))), ), ( "(default-to 3 5)", - CheckErrorKind::ExpectedOptionalType(Box::new(TypeSignature::IntType)), + StaticCheckErrorKind::ExpectedOptionalType(Box::new(TypeSignature::IntType)), ), ( "(define-private (foo (x int)) (match (some 3) x (+ x 2) 5))", - CheckErrorKind::NameAlreadyUsed("x".to_string()), + StaticCheckErrorKind::NameAlreadyUsed("x".to_string()), ), ( "(define-private (t1 (x uint)) (if (> x u1) (ok x) (err false))) @@ -695,7 +704,7 @@ fn test_destructuring_opts(#[case] version: ClarityVersion, #[case] epoch: Stack (if (> x u4) (err u3) (ok (+ u2 (try! (t1 x))))))", - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( Box::new( TypeSignature::new_response(TypeSignature::NoType, TypeSignature::BoolType) .unwrap(), @@ -710,7 +719,7 @@ fn test_destructuring_opts(#[case] version: ClarityVersion, #[case] epoch: Stack "(define-private (t1 (x uint)) (if (> x u1) (ok x) (err false))) (define-private (t2 (x uint)) (> u2 (try! (t1 x))))", - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( Box::new( TypeSignature::new_response(TypeSignature::NoType, TypeSignature::BoolType) .unwrap(), @@ -720,23 +729,23 @@ fn test_destructuring_opts(#[case] version: ClarityVersion, #[case] epoch: Stack ), ( "(try! (ok 3))", - CheckErrorKind::CouldNotDetermineResponseErrType, + StaticCheckErrorKind::CouldNotDetermineResponseErrType, ), ( "(try! none)", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(try! (err 3))", - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ), ( "(try! 3)", - CheckErrorKind::ExpectedOptionalOrResponseType(Box::new(TypeSignature::IntType)), + StaticCheckErrorKind::ExpectedOptionalOrResponseType(Box::new(TypeSignature::IntType)), ), ( "(try! (ok 3) 4)", - CheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), ), ]; @@ -759,14 +768,14 @@ fn test_at_block() { let bad = [ ( "(at-block (sha512 u0) u1)", - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_32), Box::new(TypeSignature::BUFFER_64), ), ), ( "(at-block (sha256 u0) u1 u2)", - CheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), ), ]; @@ -800,7 +809,7 @@ fn test_trait_reference_unknown(#[case] version: ClarityVersion, #[case] epoch: fn test_unexpected_use_of_field_or_trait_reference() { let bad = [( "(+ 1 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR.contract.field)", - CheckErrorKind::UnexpectedTraitOrFieldReference, + StaticCheckErrorKind::UnexpectedTraitOrFieldReference, )]; for (bad_test, expected) in bad.iter() { @@ -847,23 +856,23 @@ fn test_bitwise_bad_checks() { "(bit-or 1 2 u4)", ]; let bad_expected = [ - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::UnionTypeError( vec![IntType, UIntType], Box::new(SequenceType(StringType(ASCII( BufferLength::try_from(5u32).unwrap(), )))), ), - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::UnionTypeError(vec![IntType, UIntType], Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::UnionTypeError(vec![IntType, UIntType], Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { @@ -888,12 +897,12 @@ fn test_simple_arithmetic_checks() { "(and (or true false) (+ 1 2 3))", ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::RequiresAtLeastArguments(1, 0), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::UndefinedVariable("x".to_string()), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::RequiresAtLeastArguments(1, 0), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::UndefinedVariable("x".to_string()), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -954,14 +963,14 @@ fn test_simple_hash_checks() { for bad_test in bad_types.iter() { assert!(matches!( *type_check_helper(bad_test).unwrap_err().err, - CheckErrorKind::UnionTypeError(_, _) + StaticCheckErrorKind::UnionTypeError(_, _) )); } for bad_test in invalid_args.iter() { assert!(matches!( *type_check_helper(bad_test).unwrap_err().err, - CheckErrorKind::IncorrectArgumentCount(_, _) + StaticCheckErrorKind::IncorrectArgumentCount(_, _) )); } } @@ -984,10 +993,10 @@ fn test_simple_ifs() { ]; let bad_expected = [ - CheckErrorKind::IfArmsMustMatch(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IfArmsMustMatch(Box::new(ascii_type(1)), Box::new(BoolType)), - CheckErrorKind::IncorrectArgumentCount(3, 0), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IfArmsMustMatch(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IfArmsMustMatch(Box::new(ascii_type(1)), Box::new(BoolType)), + StaticCheckErrorKind::IncorrectArgumentCount(3, 0), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -1020,9 +1029,9 @@ fn test_simple_lets() { ]; let bad_expected = [ - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_invalid_length(0)), - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_not_atom(0)), - CheckErrorKind::TypeError( + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_invalid_length(0)), + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_not_atom(0)), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::IntType), Box::new(TypeSignature::UIntType), ), @@ -1095,47 +1104,47 @@ fn test_index_of() { ]; let bad_expected = [ - CheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), - CheckErrorKind::TypeError( + StaticCheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::IntType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_MIN), Box::new(TypeSignature::STRING_ASCII_MIN), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::STRING_UTF8_MIN), Box::new(TypeSignature::STRING_ASCII_MIN), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::STRING_ASCII_MIN), Box::new(TypeSignature::STRING_UTF8_MIN), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::list_of(TypeSignature::IntType, 1).unwrap()), Box::new(TypeSignature::list_of(TypeSignature::IntType, 2).unwrap()), ), - CheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), - CheckErrorKind::TypeError( + StaticCheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::IntType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_MIN), Box::new(TypeSignature::STRING_ASCII_MIN), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::STRING_UTF8_MIN), Box::new(TypeSignature::STRING_ASCII_MIN), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::STRING_ASCII_MIN), Box::new(TypeSignature::STRING_UTF8_MIN), ), - CheckErrorKind::CouldNotDetermineType, - CheckErrorKind::CouldNotDetermineType, - CheckErrorKind::CouldNotDetermineType, + StaticCheckErrorKind::CouldNotDetermineType, + StaticCheckErrorKind::CouldNotDetermineType, + StaticCheckErrorKind::CouldNotDetermineType, ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { @@ -1179,16 +1188,16 @@ fn test_element_at() { ]; let bad_expected = [ - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::IntType), ), - CheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), - CheckErrorKind::TypeError( + StaticCheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::UIntType), Box::new(TypeSignature::IntType), ), - CheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), + StaticCheckErrorKind::ExpectedSequence(Box::new(TypeSignature::IntType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -1220,12 +1229,12 @@ fn test_eqs(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::list_of(IntType, 1).unwrap()), Box::new(IntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::from_string( "(optional bool)", version, @@ -1263,9 +1272,9 @@ fn test_asserts() { ]; let bad_expected = [ - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -1329,23 +1338,23 @@ fn test_lists() { "(map + (list 1 2 3 4 5) (list true true true true true))", ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(2, 3), - CheckErrorKind::UnknownFunction("ynot".to_string()), - CheckErrorKind::IllegalOrUnknownFunctionApplication("if".to_string()), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::UnionTypeError(vec![IntType, UIntType], Box::new(BoolType)), - CheckErrorKind::ExpectedSequence(Box::new(UIntType)), - CheckErrorKind::ExpectedSequence(Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::UnknownFunction("ynot".to_string()), + StaticCheckErrorKind::IllegalOrUnknownFunctionApplication("if".to_string()), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::UnionTypeError(vec![IntType, UIntType], Box::new(BoolType)), + StaticCheckErrorKind::ExpectedSequence(Box::new(UIntType)), + StaticCheckErrorKind::ExpectedSequence(Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -1386,20 +1395,20 @@ fn test_buff() { "(len 1)", ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(2, 3), - CheckErrorKind::UnknownFunction("ynot".to_string()), - CheckErrorKind::IllegalOrUnknownFunctionApplication("if".to_string()), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::UnionTypeError(vec![IntType, UIntType], Box::new(BoolType)), - CheckErrorKind::ExpectedSequence(Box::new(UIntType)), - CheckErrorKind::ExpectedSequence(Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(buff_type(20))), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::UnknownFunction("ynot".to_string()), + StaticCheckErrorKind::IllegalOrUnknownFunctionApplication("if".to_string()), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::UnionTypeError(vec![IntType, UIntType], Box::new(BoolType)), + StaticCheckErrorKind::ExpectedSequence(Box::new(UIntType)), + StaticCheckErrorKind::ExpectedSequence(Box::new(IntType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -1467,9 +1476,9 @@ fn test_native_as_max_len() { "(as-max-len? 0x01 u1048577)", ]; let bad_expected = [ - CheckErrorKind::ValueTooLarge, - CheckErrorKind::ValueTooLarge, - CheckErrorKind::ValueTooLarge, + StaticCheckErrorKind::ValueTooLarge, + StaticCheckErrorKind::ValueTooLarge, + StaticCheckErrorKind::ValueTooLarge, ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { assert_eq!(*expected, *type_check_helper(bad_test).unwrap_err().err); @@ -1513,9 +1522,9 @@ fn test_native_append() { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { assert_eq!(*expected, *type_check_helper(bad_test).unwrap_err().err); @@ -1553,9 +1562,9 @@ fn test_slice_list() { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { assert_eq!(*expected, *type_check_helper(bad_test).unwrap_err().err); @@ -1584,9 +1593,9 @@ fn test_slice_buff() { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { assert_eq!(*expected, *type_check_helper(bad_test).unwrap_err().err); @@ -1618,9 +1627,9 @@ fn test_slice_ascii() { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { assert_eq!(*expected, *type_check_helper(bad_test).unwrap_err().err); @@ -1649,9 +1658,9 @@ fn test_slice_utf8() { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { assert_eq!(*expected, *type_check_helper(bad_test).unwrap_err().err); @@ -1697,17 +1706,17 @@ fn test_replace_at_list() { ]; let bad_expected = [ - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(IntType), Box::new(SequenceType(ListType( ListTypeData::new_list(IntType, 1).unwrap(), ))), ), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(3, 4), - CheckErrorKind::IncorrectArgumentCount(3, 2), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(3, 4), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::TypeError( Box::new(SequenceType(ListType( ListTypeData::new_list(IntType, 1).unwrap(), ))), @@ -1755,20 +1764,20 @@ fn test_replace_at_buff() { let buff_len = BufferLength::try_from(1u32).unwrap(); let buff_len_two = BufferLength::try_from(2u32).unwrap(); let bad_expected = [ - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(BufferType(buff_len.clone()))), Box::new(SequenceType(ListType( ListTypeData::new_list(IntType, 1).unwrap(), ))), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(BufferType(buff_len.clone()))), Box::new(SequenceType(StringType(ASCII(buff_len.clone())))), ), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(3, 4), - CheckErrorKind::IncorrectArgumentCount(3, 2), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(3, 4), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::TypeError( Box::new(SequenceType(BufferType(buff_len))), Box::new(SequenceType(BufferType(buff_len_two))), ), @@ -1813,20 +1822,20 @@ fn test_replace_at_ascii() { let buff_len = BufferLength::try_from(1u32).unwrap(); let buff_len_two = BufferLength::try_from(2u32).unwrap(); let bad_expected = [ - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(StringType(ASCII(buff_len.clone())))), Box::new(SequenceType(ListType( ListTypeData::new_list(IntType, 1).unwrap(), ))), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(StringType(ASCII(buff_len.clone())))), Box::new(SequenceType(BufferType(buff_len.clone()))), ), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(3, 4), - CheckErrorKind::IncorrectArgumentCount(3, 2), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(3, 4), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::TypeError( Box::new(SequenceType(StringType(ASCII(buff_len)))), Box::new(SequenceType(StringType(ASCII(buff_len_two)))), ), @@ -1871,20 +1880,20 @@ fn test_replace_at_utf8() { let str_len = StringUTF8Length::try_from(1u32).unwrap(); let str_len_two = StringUTF8Length::try_from(2u32).unwrap(); let bad_expected = [ - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(StringType(UTF8(str_len.clone())))), Box::new(SequenceType(ListType( ListTypeData::new_list(IntType, 1).unwrap(), ))), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(StringType(UTF8(str_len.clone())))), Box::new(SequenceType(BufferType(buff_len))), ), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(3, 4), - CheckErrorKind::IncorrectArgumentCount(3, 2), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(3, 4), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::TypeError( Box::new(SequenceType(StringType(UTF8(str_len)))), Box::new(SequenceType(StringType(UTF8(str_len_two)))), ), @@ -1913,9 +1922,9 @@ fn test_native_concat() { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(UIntType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { assert_eq!(*expected, *type_check_helper(bad_test).unwrap_err().err); @@ -1998,8 +2007,8 @@ fn test_tuples() { ]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(BoolType), Box::new(IntType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -2023,7 +2032,7 @@ fn test_empty_tuple_should_fail() { assert_eq!( *mem_type_check(contract_src).unwrap_err().err, - CheckErrorKind::EmptyTuplesNotAllowed, + StaticCheckErrorKind::EmptyTuplesNotAllowed, ); } @@ -2103,9 +2112,9 @@ fn test_simple_uints() { let bad = ["(> u1 1)", "(to-uint true)", "(to-int false)"]; let bad_expected = [ - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), - CheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::TypeError(Box::new(UIntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(IntType)), + StaticCheckErrorKind::TypeError(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::TypeError(Box::new(UIntType), Box::new(BoolType)), ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -2137,9 +2146,9 @@ fn test_buffer_to_ints() { ]; let bad_expected = [ - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::IncorrectArgumentCount(1, 0), - CheckErrorKind::TypeError( + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 0), + StaticCheckErrorKind::TypeError( Box::new(SequenceType(BufferType( BufferLength::try_from(16_u32).unwrap(), ))), @@ -2147,7 +2156,7 @@ fn test_buffer_to_ints() { BufferLength::try_from(17_u32).unwrap(), ))), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(BufferType( BufferLength::try_from(16_u32).unwrap(), ))), @@ -2211,37 +2220,37 @@ fn test_string_to_ints() { ]; let bad_expected = [ - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::IncorrectArgumentCount(1, 0), - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 0), + StaticCheckErrorKind::UnionTypeError( vec![IntType, UIntType], Box::new(SequenceType(BufferType( BufferLength::try_from(17_u32).unwrap(), ))), ), - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::UnionTypeError( vec![IntType, UIntType], Box::new(SequenceType(StringType(ASCII( BufferLength::try_from(1_u32).unwrap(), )))), ), - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::IncorrectArgumentCount(1, 0), - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 0), + StaticCheckErrorKind::UnionTypeError( vec![IntType, UIntType], Box::new(SequenceType(BufferType( BufferLength::try_from(17_u32).unwrap(), ))), ), - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::UnionTypeError( vec![IntType, UIntType], Box::new(SequenceType(StringType(ASCII( BufferLength::try_from(1_u32).unwrap(), )))), ), - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::IncorrectArgumentCount(1, 0), - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 0), + StaticCheckErrorKind::UnionTypeError( vec![ TypeSignature::STRING_ASCII_MAX, TypeSignature::STRING_UTF8_MAX, @@ -2250,16 +2259,16 @@ fn test_string_to_ints() { BufferLength::try_from(17_u32).unwrap(), ))), ), - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::UnionTypeError( vec![ TypeSignature::STRING_ASCII_MAX, TypeSignature::STRING_UTF8_MAX, ], Box::new(IntType), ), - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::IncorrectArgumentCount(1, 0), - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 0), + StaticCheckErrorKind::UnionTypeError( vec![ TypeSignature::STRING_ASCII_MAX, TypeSignature::STRING_UTF8_MAX, @@ -2268,7 +2277,7 @@ fn test_string_to_ints() { BufferLength::try_from(17_u32).unwrap(), ))), ), - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::UnionTypeError( vec![ TypeSignature::STRING_ASCII_MAX, TypeSignature::STRING_UTF8_MAX, @@ -2323,7 +2332,7 @@ fn test_response_inference(#[case] version: ClarityVersion, #[case] epoch: Stack ]; let bad_expected = [ - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::from_string( "(response bool int)", version, @@ -2331,8 +2340,8 @@ fn test_response_inference(#[case] version: ClarityVersion, #[case] epoch: Stack )), Box::new(BoolType), ), - CheckErrorKind::ReturnTypesMustMatch(Box::new(IntType), Box::new(BoolType)), - CheckErrorKind::CouldNotDetermineResponseOkType, + StaticCheckErrorKind::ReturnTypesMustMatch(Box::new(IntType), Box::new(BoolType)), + StaticCheckErrorKind::CouldNotDetermineResponseOkType, ]; for (good_test, expected) in good.iter().zip(expected.iter()) { @@ -2450,7 +2459,7 @@ fn test_options(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) { if version < ClarityVersion::Clarity2 { assert!( match *mem_run_analysis(contract, version, epoch).unwrap_err().err { - CheckErrorKind::TypeError(t1, t2) => { + StaticCheckErrorKind::TypeError(t1, t2) => { *t1 == TypeSignature::from_string("(optional bool)", version, epoch) && *t2 == TypeSignature::from_string("(optional int)", version, epoch) } @@ -2460,7 +2469,7 @@ fn test_options(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) { } else { assert!( match *mem_run_analysis(contract, version, epoch).unwrap_err().err { - CheckErrorKind::TypeError(t1, t2) => { + StaticCheckErrorKind::TypeError(t1, t2) => { *t1 == TypeSignature::from_string("bool", version, epoch) && *t2 == TypeSignature::from_string("int", version, epoch) } @@ -2569,7 +2578,7 @@ fn test_missing_value_on_declaration_should_fail() { let res = mem_type_check(contract_src).unwrap_err(); assert!(matches!( *res.err, - CheckErrorKind::IncorrectArgumentCount(_, _) + StaticCheckErrorKind::IncorrectArgumentCount(_, _) )); } @@ -2580,7 +2589,7 @@ fn test_mismatching_type_on_declaration_should_fail() { "#; let res = mem_type_check(contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } #[test] @@ -2596,7 +2605,7 @@ fn test_mismatching_type_on_update_should_fail() { "#; let res = mem_type_check(contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } #[test] @@ -2608,7 +2617,10 @@ fn test_direct_access_to_persisted_var_should_fail() { "#; let res = mem_type_check(contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::UndefinedVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::UndefinedVariable(_) + )); } #[test] @@ -2623,7 +2635,7 @@ fn test_data_var_shadowed_by_let_should_fail() { "#; let res = mem_type_check(contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NameAlreadyUsed(_))); + assert!(matches!(*res.err, StaticCheckErrorKind::NameAlreadyUsed(_))); } #[test] @@ -2636,7 +2648,10 @@ fn test_mutating_unknown_data_var_should_fail() { "#; let res = mem_type_check(contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NoSuchDataVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::NoSuchDataVariable(_) + )); } #[test] @@ -2647,7 +2662,10 @@ fn test_accessing_unknown_data_var_should_fail() { "#; let res = mem_type_check(contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NoSuchDataVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::NoSuchDataVariable(_) + )); } #[test] @@ -2658,7 +2676,7 @@ fn test_let_shadowed_by_let_should_fail() { "#; let res = mem_type_check(contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NameAlreadyUsed(_))); + assert!(matches!(*res.err, StaticCheckErrorKind::NameAlreadyUsed(_))); } #[test] @@ -2670,7 +2688,7 @@ fn test_let_shadowed_by_nested_let_should_fail() { "#; let res = mem_type_check(contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NameAlreadyUsed(_))); + assert!(matches!(*res.err, StaticCheckErrorKind::NameAlreadyUsed(_))); } #[test] @@ -2683,7 +2701,7 @@ fn test_define_constant_shadowed_by_let_should_fail() { "#; let res = mem_type_check(contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NameAlreadyUsed(_))); + assert!(matches!(*res.err, StaticCheckErrorKind::NameAlreadyUsed(_))); } #[test] @@ -2695,7 +2713,7 @@ fn test_define_constant_shadowed_by_argument_should_fail() { "#; let res = mem_type_check(contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::NameAlreadyUsed(_))); + assert!(matches!(*res.err, StaticCheckErrorKind::NameAlreadyUsed(_))); } #[test] @@ -2895,7 +2913,7 @@ fn test_fetch_entry_mismatching_type_signatures() { ({case}))" ); let res = mem_type_check(&contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } } @@ -2910,7 +2928,10 @@ fn test_fetch_entry_unbound_variables() { ({case}))" ); let res = mem_type_check(&contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::UndefinedVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::UndefinedVariable(_) + )); } } @@ -2952,7 +2973,7 @@ fn test_insert_entry_mismatching_type_signatures() { ({case}))" ); let res = mem_type_check(&contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } } @@ -2970,7 +2991,10 @@ fn test_insert_entry_unbound_variables() { ({case}))" ); let res = mem_type_check(&contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::UndefinedVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::UndefinedVariable(_) + )); } } @@ -3010,7 +3034,7 @@ fn test_delete_entry_mismatching_type_signatures() { ({case}))" ); let res = mem_type_check(&contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } } @@ -3025,7 +3049,10 @@ fn test_delete_entry_unbound_variables() { ({case}))" ); let res = mem_type_check(&contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::UndefinedVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::UndefinedVariable(_) + )); } } @@ -3069,7 +3096,7 @@ fn test_set_entry_mismatching_type_signatures() { ({case}))" ); let res = mem_type_check(&contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::TypeError(_, _))); + assert!(matches!(*res.err, StaticCheckErrorKind::TypeError(_, _))); } } @@ -3087,7 +3114,10 @@ fn test_set_entry_unbound_variables() { ({case}))" ); let res = mem_type_check(&contract_src).unwrap_err(); - assert!(matches!(*res.err, CheckErrorKind::UndefinedVariable(_))); + assert!(matches!( + *res.err, + StaticCheckErrorKind::UndefinedVariable(_) + )); } } @@ -3203,7 +3233,7 @@ fn test_buff_negative_len() { (func 0x00)"; let res = mem_type_check(contract_src).unwrap_err(); - assert_eq!(*res.err, CheckErrorKind::ValueOutOfBounds); + assert_eq!(*res.err, StaticCheckErrorKind::ValueOutOfBounds); } #[test] @@ -3212,7 +3242,7 @@ fn test_string_ascii_negative_len() { (func \"\")"; let res = mem_type_check(contract_src).unwrap_err(); - assert_eq!(*res.err, CheckErrorKind::ValueOutOfBounds); + assert_eq!(*res.err, StaticCheckErrorKind::ValueOutOfBounds); } #[test] @@ -3221,7 +3251,7 @@ fn test_string_utf8_negative_len() { (func u\"\")"; let res = mem_type_check(contract_src).unwrap_err(); - assert_eq!(*res.err, CheckErrorKind::ValueOutOfBounds); + assert_eq!(*res.err, StaticCheckErrorKind::ValueOutOfBounds); } #[test] @@ -3265,7 +3295,7 @@ fn test_comparison_types() { r#"(>= "aaa" "aaa" "aaa")"#, ]; let bad_expected = [ - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::UnionTypeError( vec![ IntType, UIntType, @@ -3279,7 +3309,7 @@ fn test_comparison_types() { ], Box::new(PrincipalType), ), - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::UnionTypeError( vec![ IntType, UIntType, @@ -3295,7 +3325,7 @@ fn test_comparison_types() { ListTypeData::new_list(IntType, 3).unwrap(), ))), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(StringType(UTF8( StringUTF8Length::try_from(3u32).unwrap(), )))), @@ -3303,7 +3333,7 @@ fn test_comparison_types() { BufferLength::try_from(2_u32).unwrap(), )))), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(StringType(ASCII( BufferLength::try_from(3_u32).unwrap(), )))), @@ -3311,7 +3341,7 @@ fn test_comparison_types() { BufferLength::try_from(2_u32).unwrap(), ))), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(BufferType( BufferLength::try_from(2_u32).unwrap(), ))), @@ -3319,7 +3349,7 @@ fn test_comparison_types() { StringUTF8Length::try_from(3u32).unwrap(), )))), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(BufferType( BufferLength::try_from(2_u32).unwrap(), ))), @@ -3327,9 +3357,9 @@ fn test_comparison_types() { BufferLength::try_from(3_u32).unwrap(), )))), ), - CheckErrorKind::IncorrectArgumentCount(2, 0), - CheckErrorKind::IncorrectArgumentCount(2, 1), - CheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::IncorrectArgumentCount(2, 0), + StaticCheckErrorKind::IncorrectArgumentCount(2, 1), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { @@ -3358,9 +3388,9 @@ fn test_principal_destruct() { r#"(principal-destruct? 0x22)"#, ]; let bad_expected = [ - CheckErrorKind::IncorrectArgumentCount(1, 2), - CheckErrorKind::IncorrectArgumentCount(1, 0), - CheckErrorKind::TypeError( + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 0), + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::PrincipalType), Box::new(TypeSignature::BUFFER_1), ), @@ -3414,17 +3444,17 @@ fn test_principal_construct() { // Too few arguments, just has the `(buff 1)`. ( r#"(principal-construct? 0x22)"#, - CheckErrorKind::RequiresAtLeastArguments(2, 1), + StaticCheckErrorKind::RequiresAtLeastArguments(2, 1), ), // Too few arguments, just hs the `(buff 20)`. ( r#"(principal-construct? 0xfa6bf38ed557fe417333710d6033e9419391a320)"#, - CheckErrorKind::RequiresAtLeastArguments(2, 1), + StaticCheckErrorKind::RequiresAtLeastArguments(2, 1), ), // The first buffer is too long, should be `(buff 1)`. ( r#"(principal-construct? 0xfa6bf38ed557fe417333710d6033e9419391a320 0xfa6bf38ed557fe417333710d6033e9419391a320)"#, - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_1), Box::new(TypeSignature::BUFFER_20), ), @@ -3432,7 +3462,7 @@ fn test_principal_construct() { // The second buffer is too long, should be `(buff 20)`. ( r#"(principal-construct? 0x22 0xfa6bf38ed557fe417333710d6033e9419391a32009)"#, - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_20), Box::new(TypeSignature::SequenceType(SequenceSubtype::BufferType( 21_u32.try_into().unwrap(), @@ -3442,12 +3472,15 @@ fn test_principal_construct() { // `int` argument instead of `(buff 1)` for version. ( r#"(principal-construct? 22 0xfa6bf38ed557fe417333710d6033e9419391a320)"#, - CheckErrorKind::TypeError(Box::new(TypeSignature::BUFFER_1), Box::new(IntType.clone())), + StaticCheckErrorKind::TypeError( + Box::new(TypeSignature::BUFFER_1), + Box::new(IntType.clone()), + ), ), // `name` argument is too long ( r#"(principal-construct? 0x22 0xfa6bf38ed557fe417333710d6033e9419391a320 "foooooooooooooooooooooooooooooooooooooooo")"#, - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::CONTRACT_NAME_STRING_ASCII_MAX), Box::new(SequenceType(StringType(ASCII(41_u32.try_into().unwrap())))), ), @@ -3455,7 +3488,7 @@ fn test_principal_construct() { // bad argument type for `name` ( r#"(principal-construct? 0x22 0xfa6bf38ed557fe417333710d6033e9419391a320 u123)"#, - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::CONTRACT_NAME_STRING_ASCII_MAX), Box::new(UIntType), ), @@ -3463,7 +3496,7 @@ fn test_principal_construct() { // too many arguments ( r#"(principal-construct? 0x22 0xfa6bf38ed557fe417333710d6033e9419391a320 "foo" "bar")"#, - CheckErrorKind::RequiresAtMostArguments(3, 4), + StaticCheckErrorKind::RequiresAtMostArguments(3, 4), ), ]; @@ -3517,7 +3550,7 @@ fn test_trait_args() { )"]; let contract_identifier = QualifiedContractIdentifier::transient(); - let bad_expected = [CheckErrorKind::IncompatibleTrait( + let bad_expected = [StaticCheckErrorKind::IncompatibleTrait( Box::new(TraitIdentifier { name: ClarityName::from("trait-foo"), contract_identifier: contract_identifier.clone(), @@ -3683,15 +3716,15 @@ fn test_list_arg(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) ", ]; let bad_expected = [ - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::list_of(TypeSignature::IntType, 3).unwrap()), Box::new(TypeSignature::list_of(TypeSignature::IntType, 4).unwrap()), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::list_of(TypeSignature::IntType, 3).unwrap()), Box::new(TypeSignature::list_of(TypeSignature::UIntType, 1).unwrap()), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::list_of(TypeSignature::IntType, 3).unwrap()), Box::new( TypeSignature::list_of( @@ -3703,15 +3736,15 @@ fn test_list_arg(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) ), ]; let bad_expected2 = [ - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::list_of(TypeSignature::IntType, 3).unwrap()), Box::new(TypeSignature::list_of(TypeSignature::IntType, 4).unwrap()), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::IntType), Box::new(TypeSignature::UIntType), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::IntType), Box::new(TypeSignature::list_of(TypeSignature::NoType, 0).unwrap()), ), @@ -3823,17 +3856,17 @@ fn test_simple_bad_syntax_bindings() { "(from-consensus-buff? (tuple (a (string-ascii -12))) 0x00)", ]; let expected = [ - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_not_list(0)), - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_invalid_length(0)), - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_not_atom(0)), - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::eval_binding_not_list(0)), - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::eval_binding_invalid_length(0)), - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::eval_binding_not_atom(0)), - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::tuple_cons_not_list(0)), - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::tuple_cons_invalid_length(0)), - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::tuple_cons_not_atom(0)), - CheckErrorKind::ValueOutOfBounds, - CheckErrorKind::ValueOutOfBounds, + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_not_list(0)), + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_invalid_length(0)), + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::let_binding_not_atom(0)), + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::eval_binding_not_list(0)), + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::eval_binding_invalid_length(0)), + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::eval_binding_not_atom(0)), + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::tuple_cons_not_list(0)), + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::tuple_cons_invalid_length(0)), + StaticCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::tuple_cons_not_atom(0)), + StaticCheckErrorKind::ValueOutOfBounds, + StaticCheckErrorKind::ValueOutOfBounds, ]; for (bad_code, expected_err) in bad.iter().zip(expected.iter()) { @@ -3857,9 +3890,9 @@ fn test_nested_bad_type_signature_syntax_bindings() { ]; let expected = [ - CheckErrorKind::ValueOutOfBounds, - CheckErrorKind::InvalidTypeDescription, - CheckErrorKind::ValueOutOfBounds, + StaticCheckErrorKind::ValueOutOfBounds, + StaticCheckErrorKind::InvalidTypeDescription, + StaticCheckErrorKind::ValueOutOfBounds, ]; for (bad_code, expected_err) in bad.iter().zip(expected.iter()) { diff --git a/clarity/src/vm/analysis/types.rs b/clarity/src/vm/analysis/types.rs index 1be8f15918e..58f08e8de95 100644 --- a/clarity/src/vm/analysis/types.rs +++ b/clarity/src/vm/analysis/types.rs @@ -22,7 +22,7 @@ use stacks_common::types::StacksEpochId; use crate::vm::analysis::analysis_db::AnalysisDatabase; use crate::vm::analysis::contract_interface_builder::ContractInterface; -use crate::vm::analysis::errors::{CheckErrorKind, StaticCheckError}; +use crate::vm::analysis::errors::{StaticCheckError, StaticCheckErrorKind}; use crate::vm::analysis::type_checker::contexts::TypeMap; use crate::vm::costs::LimitedCostTracker; use crate::vm::types::signatures::FunctionSignature; @@ -242,7 +242,7 @@ impl ContractAnalysis { | (None, Some(FunctionType::Fixed(func))) => { let args_sig = func.args.iter().map(|a| a.signature.clone()).collect(); if !expected_sig.check_args_trait_compliance(epoch, args_sig)? { - return Err(CheckErrorKind::BadTraitImplementation( + return Err(StaticCheckErrorKind::BadTraitImplementation( trait_name, func_name.to_string(), ) @@ -250,7 +250,7 @@ impl ContractAnalysis { } if !expected_sig.returns.admits_type(epoch, &func.returns)? { - return Err(CheckErrorKind::BadTraitImplementation( + return Err(StaticCheckErrorKind::BadTraitImplementation( trait_name, func_name.to_string(), ) @@ -258,7 +258,7 @@ impl ContractAnalysis { } } (_, _) => { - return Err(CheckErrorKind::BadTraitImplementation( + return Err(StaticCheckErrorKind::BadTraitImplementation( trait_name, func_name.to_string(), ) diff --git a/clarity/src/vm/clarity.rs b/clarity/src/vm/clarity.rs index ef51074c72a..bd06b628c46 100644 --- a/clarity/src/vm/clarity.rs +++ b/clarity/src/vm/clarity.rs @@ -2,7 +2,9 @@ use std::fmt; use stacks_common::types::StacksEpochId; -use crate::vm::analysis::{AnalysisDatabase, CheckErrorKind, ContractAnalysis, StaticCheckError}; +use crate::vm::analysis::{ + AnalysisDatabase, CheckErrorKind, ContractAnalysis, StaticCheckError, StaticCheckErrorKind, +}; use crate::vm::ast::errors::{ParseError, ParseErrorKind}; use crate::vm::ast::ContractAST; use crate::vm::contexts::{AssetMap, Environment, OwnedEnvironment}; @@ -76,17 +78,18 @@ impl std::error::Error for ClarityError { } } +#[cfg(any(test, feature = "testing"))] impl From for ClarityError { fn from(e: StaticCheckError) -> Self { match *e.err { - CheckErrorKind::CostOverflow => { + StaticCheckErrorKind::CostOverflow => { ClarityError::CostError(ExecutionCost::max_value(), ExecutionCost::max_value()) } - CheckErrorKind::CostBalanceExceeded(a, b) => ClarityError::CostError(a, b), - CheckErrorKind::MemoryBalanceExceeded(_a, _b) => { + StaticCheckErrorKind::CostBalanceExceeded(a, b) => ClarityError::CostError(a, b), + StaticCheckErrorKind::MemoryBalanceExceeded(_a, _b) => { ClarityError::CostError(ExecutionCost::max_value(), ExecutionCost::max_value()) } - CheckErrorKind::ExecutionTimeExpired => { + StaticCheckErrorKind::ExecutionTimeExpired => { ClarityError::CostError(ExecutionCost::max_value(), ExecutionCost::max_value()) } _ => ClarityError::StaticCheck(e), @@ -255,7 +258,7 @@ pub trait TransactionConnection: ClarityConnection { let cost_track = contract_analysis.take_contract_cost_tracker(); (cost_track, Ok((contract_ast, contract_analysis))) } - Err(e) => (e.1, Err(e.0.into())), + Err(e) => (e.1, Err(ClarityError::StaticCheck(e.0))), } }) } @@ -275,13 +278,13 @@ pub trait TransactionConnection: ClarityConnection { Ok(_) => { let result = db .commit() - .map_err(|e| CheckErrorKind::Expects(format!("{e:?}")).into()); + .map_err(|e| StaticCheckErrorKind::Expects(format!("{e:?}")).into()); (cost_tracker, result) } Err(e) => { let result = db .roll_back() - .map_err(|e| CheckErrorKind::Expects(format!("{e:?}")).into()); + .map_err(|e| StaticCheckErrorKind::Expects(format!("{e:?}")).into()); if result.is_err() { (cost_tracker, result) } else { diff --git a/clarity/src/vm/errors.rs b/clarity/src/vm/errors.rs index bc3d9c1e469..11341ea05b5 100644 --- a/clarity/src/vm/errors.rs +++ b/clarity/src/vm/errors.rs @@ -21,7 +21,7 @@ pub use clarity_types::errors::{ pub use crate::vm::analysis::errors::{ check_argument_count, check_arguments_at_least, check_arguments_at_most, CheckErrorKind, - SyntaxBindingError, SyntaxBindingErrorType, + StaticCheckError, StaticCheckErrorKind, SyntaxBindingError, SyntaxBindingErrorType, }; #[cfg(test)] diff --git a/clarity/src/vm/functions/define.rs b/clarity/src/vm/functions/define.rs index 30094737998..80ac4f6988e 100644 --- a/clarity/src/vm/functions/define.rs +++ b/clarity/src/vm/functions/define.rs @@ -16,6 +16,9 @@ use std::collections::BTreeMap; +use clarity_types::errors::analysis::CommonCheckErrorKind; +use clarity_types::VmExecutionError; + use crate::vm::callables::{DefineType, DefinedFunction}; use crate::vm::contexts::{ContractContext, Environment, LocalContext}; use crate::vm::errors::{ @@ -288,7 +291,7 @@ impl<'a> DefineFunctionsParsed<'a> { /// a define-statement, returns None if the supplied expression is not a define. pub fn try_parse( expression: &'a SymbolicExpression, - ) -> std::result::Result>, CheckErrorKind> { + ) -> std::result::Result>, CommonCheckErrorKind> { let (define_type, args) = match DefineFunctions::try_parse(expression) { Some(x) => x, None => return Ok(None), @@ -296,7 +299,9 @@ impl<'a> DefineFunctionsParsed<'a> { let result = match define_type { DefineFunctions::Constant => { check_argument_count(2, args)?; - let name = args[0].match_atom().ok_or(CheckErrorKind::ExpectedName)?; + let name = args[0] + .match_atom() + .ok_or(CommonCheckErrorKind::ExpectedName)?; DefineFunctionsParsed::Constant { name, value: &args[1], @@ -306,7 +311,7 @@ impl<'a> DefineFunctionsParsed<'a> { check_argument_count(2, args)?; let signature = args[0] .match_list() - .ok_or(CheckErrorKind::DefineFunctionBadSignature)?; + .ok_or(CommonCheckErrorKind::DefineFunctionBadSignature)?; DefineFunctionsParsed::PrivateFunction { signature, body: &args[1], @@ -316,7 +321,7 @@ impl<'a> DefineFunctionsParsed<'a> { check_argument_count(2, args)?; let signature = args[0] .match_list() - .ok_or(CheckErrorKind::DefineFunctionBadSignature)?; + .ok_or(CommonCheckErrorKind::DefineFunctionBadSignature)?; DefineFunctionsParsed::ReadOnlyFunction { signature, body: &args[1], @@ -326,7 +331,7 @@ impl<'a> DefineFunctionsParsed<'a> { check_argument_count(2, args)?; let signature = args[0] .match_list() - .ok_or(CheckErrorKind::DefineFunctionBadSignature)?; + .ok_or(CommonCheckErrorKind::DefineFunctionBadSignature)?; DefineFunctionsParsed::PublicFunction { signature, body: &args[1], @@ -334,7 +339,9 @@ impl<'a> DefineFunctionsParsed<'a> { } DefineFunctions::NonFungibleToken => { check_argument_count(2, args)?; - let name = args[0].match_atom().ok_or(CheckErrorKind::ExpectedName)?; + let name = args[0] + .match_atom() + .ok_or(CommonCheckErrorKind::ExpectedName)?; DefineFunctionsParsed::NonFungibleToken { name, nft_type: &args[1], @@ -342,7 +349,9 @@ impl<'a> DefineFunctionsParsed<'a> { } DefineFunctions::FungibleToken => { check_arguments_at_least(1, args)?; - let name = args[0].match_atom().ok_or(CheckErrorKind::ExpectedName)?; + let name = args[0] + .match_atom() + .ok_or(CommonCheckErrorKind::ExpectedName)?; if args.len() == 1 { DefineFunctionsParsed::UnboundedFungibleToken { name } } else if args.len() == 2 { @@ -351,12 +360,14 @@ impl<'a> DefineFunctionsParsed<'a> { max_supply: &args[1], } } else { - return Err(CheckErrorKind::IncorrectArgumentCount(1, args.len())); + return Err(CommonCheckErrorKind::IncorrectArgumentCount(1, args.len())); } } DefineFunctions::Map => { check_argument_count(3, args)?; - let name = args[0].match_atom().ok_or(CheckErrorKind::ExpectedName)?; + let name = args[0] + .match_atom() + .ok_or(CommonCheckErrorKind::ExpectedName)?; DefineFunctionsParsed::Map { name, key_type: &args[1], @@ -365,7 +376,9 @@ impl<'a> DefineFunctionsParsed<'a> { } DefineFunctions::PersistedVariable => { check_argument_count(3, args)?; - let name = args[0].match_atom().ok_or(CheckErrorKind::ExpectedName)?; + let name = args[0] + .match_atom() + .ok_or(CommonCheckErrorKind::ExpectedName)?; DefineFunctionsParsed::PersistedVariable { name, data_type: &args[1], @@ -374,7 +387,9 @@ impl<'a> DefineFunctionsParsed<'a> { } DefineFunctions::Trait => { check_argument_count(2, args)?; - let name = args[0].match_atom().ok_or(CheckErrorKind::ExpectedName)?; + let name = args[0] + .match_atom() + .ok_or(CommonCheckErrorKind::ExpectedName)?; DefineFunctionsParsed::Trait { name, functions: &args[1..], @@ -382,13 +397,15 @@ impl<'a> DefineFunctionsParsed<'a> { } DefineFunctions::UseTrait => { check_argument_count(2, args)?; - let name = args[0].match_atom().ok_or(CheckErrorKind::ExpectedName)?; + let name = args[0] + .match_atom() + .ok_or(CommonCheckErrorKind::ExpectedName)?; match &args[1].expr { Field(ref field) => DefineFunctionsParsed::UseTrait { name, trait_identifier: field, }, - _ => return Err(CheckErrorKind::ExpectedTraitIdentifier), + _ => return Err(CommonCheckErrorKind::ExpectedTraitIdentifier), } } DefineFunctions::ImplTrait => { @@ -397,7 +414,7 @@ impl<'a> DefineFunctionsParsed<'a> { Field(ref field) => DefineFunctionsParsed::ImplTrait { trait_identifier: field, }, - _ => return Err(CheckErrorKind::ExpectedTraitIdentifier), + _ => return Err(CommonCheckErrorKind::ExpectedTraitIdentifier), } } }; @@ -409,7 +426,9 @@ pub fn evaluate_define( expression: &SymbolicExpression, env: &mut Environment, ) -> Result { - if let Some(define_type) = DefineFunctionsParsed::try_parse(expression)? { + if let Some(define_type) = DefineFunctionsParsed::try_parse(expression) + .map_err(|e| VmExecutionError::Unchecked(e.into()))? + { match define_type { DefineFunctionsParsed::Constant { name, value } => { handle_define_variable(name, value, env) diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs index b82a028aeb3..a81641bdc89 100644 --- a/clarity/src/vm/functions/mod.rs +++ b/clarity/src/vm/functions/mod.rs @@ -14,6 +14,7 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use clarity_types::errors::analysis::CommonCheckErrorKind; use stacks_common::types::StacksEpochId; use crate::vm::callables::{cost_input_sized_vararg, CallableType, NativeHandle}; @@ -685,7 +686,7 @@ pub fn handle_binding_list( ) -> std::result::Result<(), E> where F: FnMut(&ClarityName, &SymbolicExpression) -> std::result::Result<(), E>, - E: for<'a> From<(CheckErrorKind, &'a SymbolicExpression)>, + E: for<'a> From<(CommonCheckErrorKind, &'a SymbolicExpression)>, { for (i, binding) in bindings.iter().enumerate() { let binding_expression = binding.match_list().ok_or_else(|| { diff --git a/clarity/src/vm/tests/variables.rs b/clarity/src/vm/tests/variables.rs index af65c3e24c9..cbace07f7c0 100644 --- a/clarity/src/vm/tests/variables.rs +++ b/clarity/src/vm/tests/variables.rs @@ -13,7 +13,6 @@ // // You should have received a copy of the GNU General Public License // along with this program. If not, see . - #[cfg(any(test, feature = "testing"))] use rstest::rstest; #[cfg(test)] @@ -25,7 +24,7 @@ use crate::vm::{ analysis::type_checker::v2_1::tests::contracts::type_check_version, ast::parse, database::MemoryBackingStore, - errors::{CheckErrorKind, VmExecutionError}, + errors::{CheckErrorKind, StaticCheckErrorKind, VmExecutionError}, tests::{tl_env_factory, TopLevelMemoryEnvironmentGenerator}, types::{PrincipalData, QualifiedContractIdentifier, Value}, ClarityVersion, ContractContext, @@ -54,7 +53,7 @@ fn test_block_height( if version >= ClarityVersion::Clarity3 { let err = analysis.unwrap_err(); assert_eq!( - CheckErrorKind::UndefinedVariable("block-height".to_string()), + StaticCheckErrorKind::UndefinedVariable("block-height".to_string()), *err.err ); } else { @@ -113,7 +112,7 @@ fn test_stacks_block_height( if version < ClarityVersion::Clarity3 { let err = analysis.unwrap_err(); assert_eq!( - CheckErrorKind::UndefinedVariable("stacks-block-height".to_string()), + StaticCheckErrorKind::UndefinedVariable("stacks-block-height".to_string()), *err.err ); } else { @@ -172,7 +171,7 @@ fn test_tenure_height( if version < ClarityVersion::Clarity3 { let err = analysis.unwrap_err(); assert_eq!( - CheckErrorKind::UndefinedVariable("tenure-height".to_string()), + StaticCheckErrorKind::UndefinedVariable("tenure-height".to_string()), *err.err ); } else { @@ -208,12 +207,12 @@ fn test_tenure_height( } } +#[cfg(test)] #[derive(Debug, PartialEq)] -enum WhenError { - Analysis, - Initialization, - Runtime, - Never, +enum ExpectedContractError { + Analysis(StaticCheckErrorKind), + Initialization(CheckErrorKind), + Runtime(CheckErrorKind), } #[cfg(test)] @@ -225,9 +224,8 @@ fn expect_contract_error( name: &str, contract: &str, expected_errors: &[( - WhenError, fn(ClarityVersion, StacksEpochId) -> bool, - CheckErrorKind, + ExpectedContractError, )], expected_success: Value, ) { @@ -244,13 +242,15 @@ fn expect_contract_error( type_check_version(&contract_identifier, &mut exprs, db, true, epoch, version) }); - for (when, err_condition, expected_error) in expected_errors { - if *when == WhenError::Analysis && err_condition(version, epoch) { - let err = analysis.unwrap_err(); - assert_eq!(*expected_error, *err.err); + for (err_condition, expected_error) in expected_errors { + if let ExpectedContractError::Analysis(expected_error) = expected_error { + if err_condition(version, epoch) { + let err = analysis.unwrap_err(); + assert_eq!(expected_error, &*err.err); - // Do not continue with the test if the analysis failed. - return; + // Do not continue with the test if the analysis failed. + return; + } } } @@ -270,17 +270,18 @@ fn expect_contract_error( None, ); - for (when, err_condition, expected_error) in expected_errors { - if *when == WhenError::Initialization && err_condition(version, epoch) { - let err = init_result.unwrap_err(); - if let VmExecutionError::Unchecked(inner_err) = &err { - assert_eq!(expected_error, inner_err); - } else { - panic!("Expected an Unchecked error, but got a different error"); + for (err_condition, expected_error) in expected_errors { + if let ExpectedContractError::Initialization(expected_error) = expected_error { + if err_condition(version, epoch) { + let err = init_result.unwrap_err(); + if let VmExecutionError::Unchecked(inner_err) = &err { + assert_eq!(expected_error, inner_err); + } else { + panic!("Expected an Unchecked error, but got a different error"); + } + // Do not continue with the test if the initialization failed. + return; } - - // Do not continue with the test if the initialization failed. - return; } } @@ -289,17 +290,19 @@ fn expect_contract_error( // Call the function let eval_result = env.eval_read_only(&contract_identifier, "(test-func)"); - for (when, err_condition, expected_error) in expected_errors { - if *when == WhenError::Runtime && err_condition(version, epoch) { - let err = eval_result.unwrap_err(); - if let VmExecutionError::Unchecked(inner_err) = &err { - assert_eq!(expected_error, inner_err); - } else { - panic!("Expected an Unchecked error, but got a different error"); + for (err_condition, expected_error) in expected_errors { + if let ExpectedContractError::Runtime(expected_error) = expected_error { + if err_condition(version, epoch) { + let err = eval_result.unwrap_err(); + if let VmExecutionError::Unchecked(inner_err) = &err { + assert_eq!(expected_error, inner_err); + } else { + panic!("Expected an Unchecked error, but got a different error"); + } + + // Do not continue with the test if the evaluation failed. + return; } - - // Do not continue with the test if the evaluation failed. - return; } } @@ -326,14 +329,16 @@ fn reuse_block_height( "#, &[ ( - WhenError::Initialization, |version, _| version < ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "block-height".to_string(), + )), ), ( - WhenError::Analysis, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::ReservedWord("block-height".to_string()), + ExpectedContractError::Analysis(StaticCheckErrorKind::ReservedWord( + "block-height".to_string(), + )), ), ], Value::UInt(1234), @@ -353,14 +358,16 @@ fn reuse_block_height( "#, &[ ( - WhenError::Initialization, |version, _| version < ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "block-height".to_string(), + )), ), ( - WhenError::Analysis, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::ReservedWord("block-height".to_string()), + ExpectedContractError::Analysis(StaticCheckErrorKind::ReservedWord( + "block-height".to_string(), + )), ), ], Value::Bool(true), @@ -381,14 +388,16 @@ fn reuse_block_height( "#, &[ ( - WhenError::Runtime, |version, _| version < ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("block-height".to_string()), + ExpectedContractError::Runtime(CheckErrorKind::NameAlreadyUsed( + "block-height".to_string(), + )), ), ( - WhenError::Analysis, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::ReservedWord("block-height".to_string()), + ExpectedContractError::Analysis(StaticCheckErrorKind::ReservedWord( + "block-height".to_string(), + )), ), ], Value::Int(32), @@ -412,14 +421,16 @@ fn reuse_block_height( "#, &[ ( - WhenError::Runtime, |version, _| version < ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("block-height".to_string()), + ExpectedContractError::Runtime(CheckErrorKind::NameAlreadyUsed( + "block-height".to_string(), + )), ), ( - WhenError::Analysis, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::ReservedWord("block-height".to_string()), + ExpectedContractError::Analysis(StaticCheckErrorKind::ReservedWord( + "block-height".to_string(), + )), ), ], Value::Int(3), @@ -437,14 +448,16 @@ fn reuse_block_height( "#, &[ ( - WhenError::Initialization, |version, _| version < ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "block-height".to_string(), + )), ), ( - WhenError::Analysis, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::ReservedWord("block-height".to_string()), + ExpectedContractError::Analysis(StaticCheckErrorKind::ReservedWord( + "block-height".to_string(), + )), ), ], Value::Bool(true), @@ -462,14 +475,16 @@ fn reuse_block_height( "#, &[ ( - WhenError::Initialization, |version, _| version < ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "block-height".to_string(), + )), ), ( - WhenError::Analysis, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::ReservedWord("block-height".to_string()), + ExpectedContractError::Analysis(StaticCheckErrorKind::ReservedWord( + "block-height".to_string(), + )), ), ], Value::UInt(1234), @@ -487,14 +502,16 @@ fn reuse_block_height( "#, &[ ( - WhenError::Initialization, |version, _| version < ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "block-height".to_string(), + )), ), ( - WhenError::Analysis, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::ReservedWord("block-height".to_string()), + ExpectedContractError::Analysis(StaticCheckErrorKind::ReservedWord( + "block-height".to_string(), + )), ), ], Value::Bool(false), @@ -527,14 +544,16 @@ fn reuse_block_height( "#, &[ ( - WhenError::Initialization, |version, _| version < ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "block-height".to_string(), + )), ), ( - WhenError::Analysis, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::ReservedWord("block-height".to_string()), + ExpectedContractError::Analysis(StaticCheckErrorKind::ReservedWord( + "block-height".to_string(), + )), ), ], Value::Bool(false), @@ -552,14 +571,16 @@ fn reuse_block_height( "#, &[ ( - WhenError::Initialization, |version, _| version < ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "block-height".to_string(), + )), ), ( - WhenError::Analysis, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::ReservedWord("block-height".to_string()), + ExpectedContractError::Analysis(StaticCheckErrorKind::ReservedWord( + "block-height".to_string(), + )), ), ], Value::Bool(false), @@ -577,14 +598,16 @@ fn reuse_block_height( "#, &[ ( - WhenError::Initialization, |version, _| version < ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "block-height".to_string(), + )), ), ( - WhenError::Analysis, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::ReservedWord("block-height".to_string()), + ExpectedContractError::Analysis(StaticCheckErrorKind::ReservedWord( + "block-height".to_string(), + )), ), ], Value::Bool(true), @@ -602,14 +625,16 @@ fn reuse_block_height( "#, &[ ( - WhenError::Initialization, |version, _| version < ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "block-height".to_string(), + )), ), ( - WhenError::Analysis, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::ReservedWord("block-height".to_string()), + ExpectedContractError::Analysis(StaticCheckErrorKind::ReservedWord( + "block-height".to_string(), + )), ), ], Value::Bool(true), @@ -635,9 +660,10 @@ fn reuse_stacks_block_height( ) "#, &[( - WhenError::Initialization, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("stacks-block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "stacks-block-height".to_string(), + )), )], Value::UInt(1234), ); @@ -655,9 +681,10 @@ fn reuse_stacks_block_height( ) "#, &[( - WhenError::Initialization, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("stacks-block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "stacks-block-height".to_string(), + )), )], Value::Bool(true), ); @@ -676,9 +703,10 @@ fn reuse_stacks_block_height( ) "#, &[( - WhenError::Runtime, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("stacks-block-height".to_string()), + ExpectedContractError::Runtime(CheckErrorKind::NameAlreadyUsed( + "stacks-block-height".to_string(), + )), )], Value::Int(32), ); @@ -700,9 +728,10 @@ fn reuse_stacks_block_height( ) "#, &[( - WhenError::Runtime, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("stacks-block-height".to_string()), + ExpectedContractError::Runtime(CheckErrorKind::NameAlreadyUsed( + "stacks-block-height".to_string(), + )), )], Value::Int(3), ); @@ -718,9 +747,10 @@ fn reuse_stacks_block_height( (define-private (test-func) (stacks-block-height)) "#, &[( - WhenError::Initialization, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("stacks-block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "stacks-block-height".to_string(), + )), )], Value::Bool(true), ); @@ -736,9 +766,10 @@ fn reuse_stacks_block_height( (define-read-only (test-func) stacks-block-height) "#, &[( - WhenError::Initialization, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("stacks-block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "stacks-block-height".to_string(), + )), )], Value::UInt(1234), ); @@ -754,9 +785,10 @@ fn reuse_stacks_block_height( (define-read-only (test-func) false) "#, &[( - WhenError::Initialization, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("stacks-block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "stacks-block-height".to_string(), + )), )], Value::Bool(false), ); @@ -787,9 +819,10 @@ fn reuse_stacks_block_height( (define-read-only (test-func) false) "#, &[( - WhenError::Initialization, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("stacks-block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "stacks-block-height".to_string(), + )), )], Value::Bool(false), ); @@ -805,9 +838,10 @@ fn reuse_stacks_block_height( (define-read-only (test-func) false) "#, &[( - WhenError::Initialization, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("stacks-block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "stacks-block-height".to_string(), + )), )], Value::Bool(false), ); @@ -823,9 +857,10 @@ fn reuse_stacks_block_height( (define-private (test-func) (unwrap-panic (stacks-block-height))) "#, &[( - WhenError::Initialization, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("stacks-block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "stacks-block-height".to_string(), + )), )], Value::Bool(true), ); @@ -841,9 +876,10 @@ fn reuse_stacks_block_height( (define-private (test-func) (stacks-block-height)) "#, &[( - WhenError::Initialization, |version, _| version >= ClarityVersion::Clarity3, - CheckErrorKind::NameAlreadyUsed("stacks-block-height".to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + "stacks-block-height".to_string(), + )), )], Value::Bool(true), ); @@ -872,9 +908,10 @@ fn reuse_builtin_name( "# ), &[( - WhenError::Initialization, version_check, - CheckErrorKind::NameAlreadyUsed(name.to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + name.to_string(), + )), )], Value::UInt(1234), ); @@ -894,9 +931,10 @@ fn reuse_builtin_name( "# ), &[( - WhenError::Initialization, version_check, - CheckErrorKind::NameAlreadyUsed(name.to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + name.to_string(), + )), )], Value::Bool(true), ); @@ -917,9 +955,8 @@ fn reuse_builtin_name( "# ), &[( - WhenError::Runtime, version_check, - CheckErrorKind::NameAlreadyUsed(name.to_string()), + ExpectedContractError::Runtime(CheckErrorKind::NameAlreadyUsed(name.to_string())), )], Value::Int(32), ); @@ -943,9 +980,8 @@ fn reuse_builtin_name( "# ), &[( - WhenError::Runtime, version_check, - CheckErrorKind::NameAlreadyUsed(name.to_string()), + ExpectedContractError::Runtime(CheckErrorKind::NameAlreadyUsed(name.to_string())), )], Value::Int(3), ); @@ -963,9 +999,10 @@ fn reuse_builtin_name( "# ), &[( - WhenError::Initialization, version_check, - CheckErrorKind::NameAlreadyUsed(name.to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + name.to_string(), + )), )], Value::Bool(true), ); @@ -983,9 +1020,10 @@ fn reuse_builtin_name( "# ), &[( - WhenError::Initialization, version_check, - CheckErrorKind::NameAlreadyUsed(name.to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + name.to_string(), + )), )], Value::UInt(1234), ); @@ -1003,9 +1041,10 @@ fn reuse_builtin_name( "# ), &[( - WhenError::Initialization, version_check, - CheckErrorKind::NameAlreadyUsed(name.to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + name.to_string(), + )), )], Value::Bool(false), ); @@ -1040,9 +1079,10 @@ fn reuse_builtin_name( "# ), &[( - WhenError::Initialization, version_check, - CheckErrorKind::NameAlreadyUsed(name.to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + name.to_string(), + )), )], Value::Bool(false), ); @@ -1060,9 +1100,10 @@ fn reuse_builtin_name( "# ), &[( - WhenError::Initialization, version_check, - CheckErrorKind::NameAlreadyUsed(name.to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + name.to_string(), + )), )], Value::Bool(false), ); @@ -1080,9 +1121,10 @@ fn reuse_builtin_name( "# ), &[( - WhenError::Initialization, version_check, - CheckErrorKind::NameAlreadyUsed(name.to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + name.to_string(), + )), )], Value::Bool(true), ); @@ -1100,9 +1142,10 @@ fn reuse_builtin_name( "# ), &[( - WhenError::Initialization, version_check, - CheckErrorKind::NameAlreadyUsed(name.to_string()), + ExpectedContractError::Initialization(CheckErrorKind::NameAlreadyUsed( + name.to_string(), + )), )], Value::Bool(true), ); @@ -1133,7 +1176,7 @@ fn test_block_time( if version < ClarityVersion::Clarity4 { let err = analysis.unwrap_err(); assert_eq!( - CheckErrorKind::UndefinedVariable("stacks-block-time".to_string()), + StaticCheckErrorKind::UndefinedVariable("stacks-block-time".to_string()), *err.err ); } else { @@ -1260,7 +1303,7 @@ fn test_current_contract( if version < ClarityVersion::Clarity4 { let err = analysis.unwrap_err(); assert_eq!( - CheckErrorKind::UndefinedVariable("current-contract".to_string()), + StaticCheckErrorKind::UndefinedVariable("current-contract".to_string()), *err.err ); } else { diff --git a/clarity/src/vm/types/signatures.rs b/clarity/src/vm/types/signatures.rs index aadf25f846d..f5f49bc796e 100644 --- a/clarity/src/vm/types/signatures.rs +++ b/clarity/src/vm/types/signatures.rs @@ -17,6 +17,7 @@ use std::collections::BTreeMap; use std::fmt; +use clarity_types::errors::analysis::CommonCheckErrorKind; pub use clarity_types::types::signatures::{ AssetIdentifier, BufferLength, CallableSubtype, ListTypeData, SequenceSubtype, StringSubtype, StringUTF8Length, TupleTypeSignature, TypeSignature, @@ -26,7 +27,7 @@ use stacks_common::types::StacksEpochId; use self::TypeSignature::SequenceType; use crate::vm::costs::{runtime_cost, CostOverflowingMath}; -use crate::vm::errors::{CheckErrorKind, SyntaxBindingError, SyntaxBindingErrorType}; +use crate::vm::errors::{SyntaxBindingError, SyntaxBindingErrorType}; use crate::vm::representations::{ ClarityName, SymbolicExpression, SymbolicExpressionType, TraitDefinition, }; @@ -162,59 +163,59 @@ impl From for FunctionSignature { /// This is not included in clarity-types because it requires the /// [`CostTracker`] trait. pub trait TypeSignatureExt { - fn parse_atom_type(typename: &str) -> Result; + fn parse_atom_type(typename: &str) -> Result; fn parse_list_type_repr( epoch: StacksEpochId, type_args: &[SymbolicExpression], accounting: &mut A, - ) -> Result; + ) -> Result; fn parse_tuple_type_repr( epoch: StacksEpochId, type_args: &[SymbolicExpression], accounting: &mut A, - ) -> Result; + ) -> Result; fn parse_buff_type_repr( type_args: &[SymbolicExpression], - ) -> Result; + ) -> Result; fn parse_string_utf8_type_repr( type_args: &[SymbolicExpression], - ) -> Result; + ) -> Result; fn parse_string_ascii_type_repr( type_args: &[SymbolicExpression], - ) -> Result; + ) -> Result; fn parse_optional_type_repr( epoch: StacksEpochId, type_args: &[SymbolicExpression], accounting: &mut A, - ) -> Result; + ) -> Result; fn parse_response_type_repr( epoch: StacksEpochId, type_args: &[SymbolicExpression], accounting: &mut A, - ) -> Result; + ) -> Result; fn parse_type_repr( epoch: StacksEpochId, x: &SymbolicExpression, accounting: &mut A, - ) -> Result; + ) -> Result; fn parse_trait_type_repr( type_args: &[SymbolicExpression], accounting: &mut A, epoch: StacksEpochId, clarity_version: ClarityVersion, - ) -> Result, CheckErrorKind>; + ) -> Result, CommonCheckErrorKind>; #[cfg(test)] fn from_string(val: &str, version: ClarityVersion, epoch: StacksEpochId) -> Self; } impl TypeSignatureExt for TypeSignature { - fn parse_atom_type(typename: &str) -> Result { + fn parse_atom_type(typename: &str) -> Result { match typename { "int" => Ok(TypeSignature::IntType), "uint" => Ok(TypeSignature::UIntType), "bool" => Ok(TypeSignature::BoolType), "principal" => Ok(TypeSignature::PrincipalType), - _ => Err(CheckErrorKind::UnknownTypeName(typename.into())), + _ => Err(CommonCheckErrorKind::UnknownTypeName(typename.into())), } } @@ -224,18 +225,19 @@ impl TypeSignatureExt for TypeSignature { epoch: StacksEpochId, type_args: &[SymbolicExpression], accounting: &mut A, - ) -> Result { + ) -> Result { if type_args.len() != 2 { - return Err(CheckErrorKind::InvalidTypeDescription); + return Err(CommonCheckErrorKind::InvalidTypeDescription); } if let SymbolicExpressionType::LiteralValue(Value::Int(max_len)) = &type_args[0].expr { let atomic_type_arg = &type_args[type_args.len() - 1]; let entry_type = TypeSignature::parse_type_repr(epoch, atomic_type_arg, accounting)?; - let max_len = u32::try_from(*max_len).map_err(|_| CheckErrorKind::ValueTooLarge)?; + let max_len = + u32::try_from(*max_len).map_err(|_| CommonCheckErrorKind::ValueTooLarge)?; ListTypeData::new_list(entry_type, max_len).map(|x| x.into()) } else { - Err(CheckErrorKind::InvalidTypeDescription) + Err(CommonCheckErrorKind::InvalidTypeDescription) } } @@ -245,8 +247,8 @@ impl TypeSignatureExt for TypeSignature { epoch: StacksEpochId, type_args: &[SymbolicExpression], accounting: &mut A, - ) -> Result { - let mapped_key_types = parse_name_type_pairs::<_, CheckErrorKind>( + ) -> Result { + let mapped_key_types = parse_name_type_pairs::<_, CommonCheckErrorKind>( epoch, type_args, SyntaxBindingErrorType::TupleCons, @@ -260,15 +262,15 @@ impl TypeSignatureExt for TypeSignature { // (buff 10) fn parse_buff_type_repr( type_args: &[SymbolicExpression], - ) -> Result { + ) -> Result { if type_args.len() != 1 { - return Err(CheckErrorKind::InvalidTypeDescription); + return Err(CommonCheckErrorKind::InvalidTypeDescription); } if let SymbolicExpressionType::LiteralValue(Value::Int(buff_len)) = &type_args[0].expr { BufferLength::try_from(*buff_len) .map(|buff_len| SequenceType(SequenceSubtype::BufferType(buff_len))) } else { - Err(CheckErrorKind::InvalidTypeDescription) + Err(CommonCheckErrorKind::InvalidTypeDescription) } } @@ -276,16 +278,16 @@ impl TypeSignatureExt for TypeSignature { // (string-utf8 10) fn parse_string_utf8_type_repr( type_args: &[SymbolicExpression], - ) -> Result { + ) -> Result { if type_args.len() != 1 { - return Err(CheckErrorKind::InvalidTypeDescription); + return Err(CommonCheckErrorKind::InvalidTypeDescription); } if let SymbolicExpressionType::LiteralValue(Value::Int(utf8_len)) = &type_args[0].expr { StringUTF8Length::try_from(*utf8_len).map(|utf8_len| { SequenceType(SequenceSubtype::StringType(StringSubtype::UTF8(utf8_len))) }) } else { - Err(CheckErrorKind::InvalidTypeDescription) + Err(CommonCheckErrorKind::InvalidTypeDescription) } } @@ -293,16 +295,16 @@ impl TypeSignatureExt for TypeSignature { // (string-ascii 10) fn parse_string_ascii_type_repr( type_args: &[SymbolicExpression], - ) -> Result { + ) -> Result { if type_args.len() != 1 { - return Err(CheckErrorKind::InvalidTypeDescription); + return Err(CommonCheckErrorKind::InvalidTypeDescription); } if let SymbolicExpressionType::LiteralValue(Value::Int(buff_len)) = &type_args[0].expr { BufferLength::try_from(*buff_len).map(|buff_len| { SequenceType(SequenceSubtype::StringType(StringSubtype::ASCII(buff_len))) }) } else { - Err(CheckErrorKind::InvalidTypeDescription) + Err(CommonCheckErrorKind::InvalidTypeDescription) } } @@ -310,9 +312,9 @@ impl TypeSignatureExt for TypeSignature { epoch: StacksEpochId, type_args: &[SymbolicExpression], accounting: &mut A, - ) -> Result { + ) -> Result { if type_args.len() != 1 { - return Err(CheckErrorKind::InvalidTypeDescription); + return Err(CommonCheckErrorKind::InvalidTypeDescription); } let inner_type = TypeSignature::parse_type_repr(epoch, &type_args[0], accounting)?; @@ -323,20 +325,21 @@ impl TypeSignatureExt for TypeSignature { epoch: StacksEpochId, type_args: &[SymbolicExpression], accounting: &mut A, - ) -> Result { + ) -> Result { if type_args.len() != 2 { - return Err(CheckErrorKind::InvalidTypeDescription); + return Err(CommonCheckErrorKind::InvalidTypeDescription); } let ok_type = TypeSignature::parse_type_repr(epoch, &type_args[0], accounting)?; let err_type = TypeSignature::parse_type_repr(epoch, &type_args[1], accounting)?; - TypeSignature::new_response(ok_type, err_type) + let response_type = TypeSignature::new_response(ok_type, err_type)?; + Ok(response_type) } fn parse_type_repr( epoch: StacksEpochId, x: &SymbolicExpression, accounting: &mut A, - ) -> Result { + ) -> Result { runtime_cost(ClarityCostFunction::TypeParseStep, accounting, 0)?; match x.expr { @@ -347,7 +350,7 @@ impl TypeSignatureExt for TypeSignature { SymbolicExpressionType::List(ref list_contents) => { let (compound_type, rest) = list_contents .split_first() - .ok_or(CheckErrorKind::InvalidTypeDescription)?; + .ok_or(CommonCheckErrorKind::InvalidTypeDescription)?; if let SymbolicExpressionType::Atom(ref compound_type) = compound_type.expr { match compound_type.as_ref() { "list" => TypeSignature::parse_list_type_repr(epoch, rest, accounting), @@ -361,10 +364,10 @@ impl TypeSignatureExt for TypeSignature { "response" => { TypeSignature::parse_response_type_repr(epoch, rest, accounting) } - _ => Err(CheckErrorKind::InvalidTypeDescription), + _ => Err(CommonCheckErrorKind::InvalidTypeDescription), } } else { - Err(CheckErrorKind::InvalidTypeDescription) + Err(CommonCheckErrorKind::InvalidTypeDescription) } } SymbolicExpressionType::TraitReference(_, ref trait_definition) @@ -389,7 +392,7 @@ impl TypeSignatureExt for TypeSignature { )), } } - _ => Err(CheckErrorKind::InvalidTypeDescription), + _ => Err(CommonCheckErrorKind::InvalidTypeDescription), } } @@ -398,43 +401,43 @@ impl TypeSignatureExt for TypeSignature { accounting: &mut A, epoch: StacksEpochId, clarity_version: ClarityVersion, - ) -> Result, CheckErrorKind> { + ) -> Result, CommonCheckErrorKind> { let mut trait_signature: BTreeMap = BTreeMap::new(); let functions_types = type_args .first() - .ok_or_else(|| CheckErrorKind::InvalidTypeDescription)? + .ok_or_else(|| CommonCheckErrorKind::InvalidTypeDescription)? .match_list() - .ok_or(CheckErrorKind::DefineTraitBadSignature)?; + .ok_or(CommonCheckErrorKind::DefineTraitBadSignature)?; for function_type in functions_types.iter() { let args = function_type .match_list() - .ok_or(CheckErrorKind::DefineTraitBadSignature)?; + .ok_or(CommonCheckErrorKind::DefineTraitBadSignature)?; if args.len() != 3 { - return Err(CheckErrorKind::InvalidTypeDescription); + return Err(CommonCheckErrorKind::InvalidTypeDescription); } // Extract function's name let fn_name = args[0] .match_atom() - .ok_or(CheckErrorKind::DefineTraitBadSignature)?; + .ok_or(CommonCheckErrorKind::DefineTraitBadSignature)?; // Extract function's arguments let fn_args_exprs = args[1] .match_list() - .ok_or(CheckErrorKind::DefineTraitBadSignature)?; + .ok_or(CommonCheckErrorKind::DefineTraitBadSignature)?; let fn_args = fn_args_exprs .iter() .map(|arg_type| TypeSignature::parse_type_repr(epoch, arg_type, accounting)) - .collect::>()?; + .collect::>()?; // Extract function's type return - must be a response let fn_return = match TypeSignature::parse_type_repr(epoch, &args[2], accounting) { Ok(response) => match response { TypeSignature::ResponseType(_) => Ok(response), - _ => Err(CheckErrorKind::DefineTraitBadSignature), + _ => Err(CommonCheckErrorKind::DefineTraitBadSignature), }, - _ => Err(CheckErrorKind::DefineTraitBadSignature), + _ => Err(CommonCheckErrorKind::DefineTraitBadSignature), }?; if trait_signature @@ -448,7 +451,7 @@ impl TypeSignatureExt for TypeSignature { .is_some() && clarity_version >= ClarityVersion::Clarity2 { - return Err(CheckErrorKind::DefineTraitDuplicateMethod( + return Err(CommonCheckErrorKind::DefineTraitDuplicateMethod( fn_name.to_string(), )); } @@ -473,7 +476,7 @@ impl TypeSignatureExt for TypeSignature { } impl FixedFunction { - pub fn total_type_size(&self) -> Result { + pub fn total_type_size(&self) -> Result { let mut function_type_size = u64::from(self.returns.type_size()?); for arg in self.args.iter() { function_type_size = @@ -484,11 +487,12 @@ impl FixedFunction { } impl FunctionSignature { - pub fn total_type_size(&self) -> Result { + pub fn total_type_size(&self) -> Result { let mut function_type_size = u64::from(self.returns.type_size()?); for arg in self.args.iter() { - function_type_size = - function_type_size.cost_overflow_add(u64::from(arg.type_size()?))?; + function_type_size = function_type_size + .cost_overflow_add(u64::from(arg.type_size()?)) + .map_err(|_| CommonCheckErrorKind::CostOverflow)?; } Ok(function_type_size) } @@ -497,7 +501,7 @@ impl FunctionSignature { &self, epoch: &StacksEpochId, args: Vec, - ) -> Result { + ) -> Result { if args.len() != self.args.len() { return Ok(false); } @@ -546,7 +550,7 @@ pub fn parse_name_type_pairs( accounting: &mut A, ) -> Result, E> where - E: for<'a> From<(CheckErrorKind, &'a SymbolicExpression)>, + E: for<'a> From<(CommonCheckErrorKind, &'a SymbolicExpression)>, { // this is a pretty deep nesting here, but what we're trying to do is pick out the values of // the form: @@ -555,14 +559,14 @@ where use crate::vm::representations::SymbolicExpressionType::List; // step 1: parse it into a vec of symbolicexpression pairs. - let as_pairs: Result, (CheckErrorKind, &SymbolicExpression)> = name_type_pairs + let as_pairs: Result, (CommonCheckErrorKind, &SymbolicExpression)> = name_type_pairs .iter() .enumerate() .map(|(i, key_type_pair)| { if let List(ref as_vec) = key_type_pair.expr { if as_vec.len() != 2 { Err(( - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::InvalidLength( + CommonCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::InvalidLength( binding_error_type, i, )), @@ -581,7 +585,7 @@ where .collect(); // step 2: turn into a vec of (name, typesignature) pairs. - let key_types: Result, (CheckErrorKind, &SymbolicExpression)> = (as_pairs?) + let key_types: Result, (CommonCheckErrorKind, &SymbolicExpression)> = (as_pairs?) .iter() .enumerate() .map(|(i, (name_symbol, type_symbol))| { @@ -589,7 +593,7 @@ where .match_atom() .ok_or_else(|| { ( - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::NotAtom( + CommonCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::NotAtom( binding_error_type, i, )), @@ -614,13 +618,14 @@ impl fmt::Display for FunctionArg { #[cfg(test)] mod test { + use clarity_types::errors::CheckErrorKind; + use clarity_types::errors::CheckErrorKind::*; #[cfg(test)] use rstest::rstest; #[cfg(test)] use rstest_reuse::{self, *}; use stacks_common::types::StacksEpochId; - use super::CheckErrorKind::*; use super::*; use crate::vm::tests::test_clarity_versions; use crate::vm::types::QualifiedContractIdentifier; @@ -635,7 +640,9 @@ mod test { epoch, ) .unwrap()[0]; - TypeSignature::parse_type_repr(epoch, expr, &mut ()).unwrap_err() + TypeSignature::parse_type_repr(epoch, expr, &mut ()) + .unwrap_err() + .into() } #[apply(test_clarity_versions)] @@ -663,7 +670,7 @@ mod test { assert_eq!( TupleTypeSignature::try_from(keys).unwrap_err(), - ValueTooLarge + CommonCheckErrorKind::ValueTooLarge ); } diff --git a/stackslib/src/chainstate/stacks/boot/contract_tests.rs b/stackslib/src/chainstate/stacks/boot/contract_tests.rs index 7aae0821e5b..cb362755274 100644 --- a/stackslib/src/chainstate/stacks/boot/contract_tests.rs +++ b/stackslib/src/chainstate/stacks/boot/contract_tests.rs @@ -6,7 +6,7 @@ use clarity::vm::analysis::mem_type_check; use clarity::vm::clarity::TransactionConnection; use clarity::vm::contexts::OwnedEnvironment; use clarity::vm::database::*; -use clarity::vm::errors::{CheckErrorKind, VmExecutionError}; +use clarity::vm::errors::{CheckErrorKind, StaticCheckErrorKind, VmExecutionError}; use clarity::vm::test_util::{execute, symbols_from_values, TEST_BURN_STATE_DB, TEST_HEADER_DB}; use clarity::vm::types::{ OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, StandardPrincipalData, @@ -1713,7 +1713,7 @@ fn simple_epoch21_test() { ClarityError::StaticCheck(e) => { assert_eq!( *e.err, - CheckErrorKind::UnknownFunction("stx-account".into()) + StaticCheckErrorKind::UnknownFunction("stx-account".into()) ); } e => panic!("Should have caused an analysis error: {:#?}", e), diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__append_block_with_contract_call_success.snap.new b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__append_block_with_contract_call_success.snap.new deleted file mode 100644 index e63bca6f961..00000000000 --- a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__append_block_with_contract_call_success.snap.new +++ /dev/null @@ -1,160 +0,0 @@ ---- -source: stackslib/src/chainstate/tests/consensus.rs -assertion_line: 893 -expression: result -snapshot_kind: text ---- -[ - Success(ExpectedBlockOutput( - marf_hash: "186c8e49bcfc59bb67ed22f031f009a44681f296392e0f92bed520918ba463ae", - transactions: [ - ExpectedTransactionOutput( - return_type: Response(ResponseData( - committed: true, - data: Bool(true), - )), - cost: ExecutionCost( - write_length: 121, - write_count: 2, - read_length: 1, - read_count: 1, - runtime: 11968, - ), - ), - ExpectedTransactionOutput( - return_type: Response(ResponseData( - committed: true, - data: UInt(1), - )), - cost: ExecutionCost( - write_length: 0, - write_count: 0, - read_length: 103, - read_count: 3, - runtime: 499, - ), - ), - ], - total_block_cost: ExecutionCost( - write_length: 121, - write_count: 2, - read_length: 104, - read_count: 4, - runtime: 12467, - ), - )), - Success(ExpectedBlockOutput( - marf_hash: "ad23713f072473cad6a32125ed5fa822bb62bbfae8ed2302209c12d2f1958128", - transactions: [ - ExpectedTransactionOutput( - return_type: Response(ResponseData( - committed: true, - data: Bool(true), - )), - cost: ExecutionCost( - write_length: 121, - write_count: 2, - read_length: 1, - read_count: 1, - runtime: 11968, - ), - ), - ExpectedTransactionOutput( - return_type: Response(ResponseData( - committed: true, - data: UInt(1), - )), - cost: ExecutionCost( - write_length: 0, - write_count: 0, - read_length: 103, - read_count: 3, - runtime: 499, - ), - ), - ], - total_block_cost: ExecutionCost( - write_length: 121, - write_count: 2, - read_length: 104, - read_count: 4, - runtime: 12467, - ), - )), - Success(ExpectedBlockOutput( - marf_hash: "021bd30b09b5ac6ff34abd11f05244a966af937b584b1752f272cd717bb25f1d", - transactions: [ - ExpectedTransactionOutput( - return_type: Response(ResponseData( - committed: true, - data: Bool(true), - )), - cost: ExecutionCost( - write_length: 121, - write_count: 2, - read_length: 1, - read_count: 1, - runtime: 11968, - ), - ), - ExpectedTransactionOutput( - return_type: Response(ResponseData( - committed: true, - data: UInt(1), - )), - cost: ExecutionCost( - write_length: 0, - write_count: 0, - read_length: 103, - read_count: 3, - runtime: 499, - ), - ), - ], - total_block_cost: ExecutionCost( - write_length: 121, - write_count: 2, - read_length: 104, - read_count: 4, - runtime: 12467, - ), - )), - Success(ExpectedBlockOutput( - marf_hash: "0e2829cdc4ea57ab95e61b1c17c604c51b501ab684b75c90286623253aceac31", - transactions: [ - ExpectedTransactionOutput( - return_type: Response(ResponseData( - committed: true, - data: Bool(true), - )), - cost: ExecutionCost( - write_length: 121, - write_count: 2, - read_length: 1, - read_count: 1, - runtime: 11968, - ), - ), - ExpectedTransactionOutput( - return_type: Response(ResponseData( - committed: true, - data: UInt(1), - )), - cost: ExecutionCost( - write_length: 0, - write_count: 0, - read_length: 103, - read_count: 3, - runtime: 499, - ), - ), - ], - total_block_cost: ExecutionCost( - write_length: 121, - write_count: 2, - read_length: 104, - read_count: 4, - runtime: 12467, - ), - )), -] diff --git a/stackslib/src/clarity_cli.rs b/stackslib/src/clarity_cli.rs index 3c3bd361de5..e15060ebeab 100644 --- a/stackslib/src/clarity_cli.rs +++ b/stackslib/src/clarity_cli.rs @@ -43,7 +43,6 @@ use crate::chainstate::stacks::boot::{ }; use crate::chainstate::stacks::index::ClarityMarfTrieId; use crate::clarity::vm::analysis::contract_interface_builder::build_contract_interface; -use crate::clarity::vm::analysis::errors::StaticCheckError; use crate::clarity::vm::analysis::{AnalysisDatabase, ContractAnalysis}; use crate::clarity::vm::ast::build_ast; use crate::clarity::vm::contexts::{AssetMap, GlobalContext, OwnedEnvironment}; @@ -51,7 +50,9 @@ use crate::clarity::vm::costs::{ExecutionCost, LimitedCostTracker}; use crate::clarity::vm::database::{ BurnStateDB, ClarityDatabase, HeadersDB, STXBalance, NULL_BURN_STATE_DB, }; -use crate::clarity::vm::errors::{InterpreterResult, RuntimeError, VmExecutionError}; +use crate::clarity::vm::errors::{ + InterpreterResult, RuntimeError, StaticCheckError, VmExecutionError, +}; use crate::clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; use crate::clarity::vm::{ analysis, ast, eval_all, ClarityVersion, ContractContext, ContractName, SymbolicExpression, diff --git a/stackslib/src/clarity_vm/tests/analysis_costs.rs b/stackslib/src/clarity_vm/tests/analysis_costs.rs index 5d60bd86c92..ecb9c5827ba 100644 --- a/stackslib/src/clarity_vm/tests/analysis_costs.rs +++ b/stackslib/src/clarity_vm/tests/analysis_costs.rs @@ -16,7 +16,7 @@ use clarity::vm::clarity::{ClarityError, TransactionConnection}; use clarity::vm::costs::ExecutionCost; -use clarity::vm::errors::CheckErrorKind; +use clarity::vm::errors::StaticCheckErrorKind; use clarity::vm::functions::NativeFunctions; use clarity::vm::test_util::TEST_HEADER_DB; use clarity::vm::tests::{test_only_mainnet_to_chain_id, UnitTestBurnStateDB}; @@ -317,7 +317,7 @@ fn undefined_top_variable_error(#[case] use_mainnet: bool, #[case] epoch: Stacks let Err(ClarityError::StaticCheck(check_error)) = analysis_result else { panic!("Bad analysis result: {analysis_result:?}"); }; - let CheckErrorKind::UndefinedVariable(var_name) = *check_error.err else { + let StaticCheckErrorKind::UndefinedVariable(var_name) = *check_error.err else { panic!("Bad analysis error: {check_error:?}"); }; assert_eq!(var_name, "foo".to_string()); diff --git a/stackslib/src/clarity_vm/tests/contracts.rs b/stackslib/src/clarity_vm/tests/contracts.rs index bc8a2c96dd5..ce90e4a8ecb 100644 --- a/stackslib/src/clarity_vm/tests/contracts.rs +++ b/stackslib/src/clarity_vm/tests/contracts.rs @@ -16,7 +16,7 @@ use clarity::types::StacksEpochId; use clarity::vm::clarity::ClarityError; -use clarity::vm::errors::{CheckErrorKind, VmExecutionError}; +use clarity::vm::errors::{CheckErrorKind, StaticCheckErrorKind, VmExecutionError}; use clarity::vm::types::SequenceData::Buffer; use clarity::vm::types::{ BuffData, OptionalData, PrincipalData, QualifiedContractIdentifier, TupleData, TypeSignature, @@ -49,7 +49,7 @@ fn test_get_burn_block_info_eval() { let res = clarity_db.analyze_smart_contract(&contract_identifier, clarity_version, contract); if let Err(ClarityError::StaticCheck(check_error)) = res { - if let CheckErrorKind::UnknownFunction(func_name) = *check_error.err { + if let StaticCheckErrorKind::UnknownFunction(func_name) = *check_error.err { assert_eq!(func_name, "get-burn-block-info?"); } else { panic!("Bad analysis error: {:?}", &check_error); @@ -70,7 +70,7 @@ fn test_get_burn_block_info_eval() { let res = clarity_db.analyze_smart_contract(&contract_identifier, clarity_version, contract); if let Err(ClarityError::StaticCheck(check_error)) = res { - if let CheckErrorKind::UnknownFunction(func_name) = *check_error.err { + if let StaticCheckErrorKind::UnknownFunction(func_name) = *check_error.err { assert_eq!(func_name, "get-burn-block-info?"); } else { panic!("Bad analysis error: {:?}", &check_error); @@ -162,7 +162,7 @@ fn test_get_block_info_eval_v210() { let res = clarity_db.analyze_smart_contract(&contract_identifier, clarity_version, contract); if let Err(ClarityError::StaticCheck(check_error)) = res { - if let CheckErrorKind::NoSuchBlockInfoProperty(name) = *check_error.err { + if let StaticCheckErrorKind::NoSuchBlockInfoProperty(name) = *check_error.err { assert_eq!(name, "block-reward"); } else { panic!("Bad analysis error: {:?}", &check_error); @@ -183,7 +183,7 @@ fn test_get_block_info_eval_v210() { let res = clarity_db.analyze_smart_contract(&contract_identifier, clarity_version, contract); if let Err(ClarityError::StaticCheck(check_error)) = res { - if let CheckErrorKind::NoSuchBlockInfoProperty(name) = *check_error.err { + if let StaticCheckErrorKind::NoSuchBlockInfoProperty(name) = *check_error.err { assert_eq!(name, "block-reward"); } else { panic!("Bad analysis error: {:?}", &check_error); @@ -345,7 +345,7 @@ fn trait_invocation_205_with_stored_principal() { .unwrap_err(); match error { ClarityError::StaticCheck(ref e) => match *e.err { - CheckErrorKind::TypeError(..) => (), + StaticCheckErrorKind::TypeError(..) => (), _ => panic!("Unexpected error: {:?}", error), }, _ => panic!("Unexpected error: {:?}", error), @@ -876,7 +876,7 @@ fn test_block_heights() { contract_clarity3, ); if let Err(ClarityError::StaticCheck(check_error)) = res { - if let CheckErrorKind::UndefinedVariable(var_name) = *check_error.err { + if let StaticCheckErrorKind::UndefinedVariable(var_name) = *check_error.err { assert_eq!(var_name, "stacks-block-height"); } else { panic!("Bad analysis error: {:?}", &check_error); @@ -910,7 +910,7 @@ fn test_block_heights() { contract_clarity3, ); if let Err(ClarityError::StaticCheck(check_error)) = res { - if let CheckErrorKind::UndefinedVariable(var_name) = *check_error.err { + if let StaticCheckErrorKind::UndefinedVariable(var_name) = *check_error.err { assert_eq!(var_name, "stacks-block-height"); } else { panic!("Bad analysis error: {:?}", &check_error); @@ -926,7 +926,7 @@ fn test_block_heights() { contract_clarity1, ); if let Err(ClarityError::StaticCheck(check_error)) = res { - if let CheckErrorKind::UndefinedVariable(var_name) = *check_error.err { + if let StaticCheckErrorKind::UndefinedVariable(var_name) = *check_error.err { assert_eq!(var_name, "block-height"); } else { panic!("Bad analysis error: {:?}", &check_error); From a043b86c50bb68d9c550702b1d94e541f9af2ea9 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Mon, 3 Nov 2025 16:40:16 +0000 Subject: [PATCH 02/40] remove unnecessary From conversions. total_type_size return StaticCheckErrorKind> --- clarity-types/src/errors/analysis.rs | 14 ++++++-------- clarity-types/src/errors/mod.rs | 16 ++++++++-------- clarity-types/src/types/serialization.rs | 20 +++++++------------- clarity-types/src/types/signatures.rs | 13 ++++++------- clarity/src/vm/types/signatures.rs | 8 ++++---- 5 files changed, 31 insertions(+), 40 deletions(-) diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index 43269e5c6e7..fb61e5af0e2 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -871,17 +871,15 @@ impl StaticCheckError { } } -impl From<(SyntaxBindingError, &SymbolicExpression)> for StaticCheckError { - fn from(e: (SyntaxBindingError, &SymbolicExpression)) -> Self { - Self::with_expression(StaticCheckErrorKind::BadSyntaxBinding(e.0), e.1) +impl From<(CommonCheckErrorKind, &SymbolicExpression)> for StaticCheckError { + fn from(e: (CommonCheckErrorKind, &SymbolicExpression)) -> Self { + Self::with_expression(e.0.into(), e.1) } } -impl From<(CommonCheckErrorKind, &SymbolicExpression)> for StaticCheckError { - fn from(e: (CommonCheckErrorKind, &SymbolicExpression)) -> Self { - let mut ce = Self::new(e.0.into()); - ce.set_expression(e.1); - ce +impl From<(SyntaxBindingError, &SymbolicExpression)> for StaticCheckError { + fn from(e: (SyntaxBindingError, &SymbolicExpression)) -> Self { + Self::with_expression(StaticCheckErrorKind::BadSyntaxBinding(e.0), e.1) } } diff --git a/clarity-types/src/errors/mod.rs b/clarity-types/src/errors/mod.rs index 4e9948dccf3..4dae0f9ebe8 100644 --- a/clarity-types/src/errors/mod.rs +++ b/clarity-types/src/errors/mod.rs @@ -275,14 +275,6 @@ impl From for VmExecutionError { } } -// TODO: remove. CommonCheckErrorKind shouldn't be used in the public API. -// So there shouldn't be any need to convert it to a VmExecutionError. -impl From for VmExecutionError { - fn from(err: CommonCheckErrorKind) -> Self { - VmExecutionError::Unchecked(err.into()) - } -} - impl From for VmExecutionError { fn from(err: CostErrors) -> Self { match err { @@ -303,6 +295,14 @@ impl From for VmExecutionError { } } +// TODO: remove. CommonCheckErrorKind shouldn't be used in the public API. +// So there shouldn't be any need to convert it to a VmExecutionError. +impl From for VmExecutionError { + fn from(err: CommonCheckErrorKind) -> Self { + VmExecutionError::Unchecked(err.into()) + } +} + impl From for VmExecutionError { fn from(err: CheckErrorKind) -> Self { VmExecutionError::Unchecked(err) diff --git a/clarity-types/src/types/serialization.rs b/clarity-types/src/types/serialization.rs index 019beb38f49..9747aca13de 100644 --- a/clarity-types/src/types/serialization.rs +++ b/clarity-types/src/types/serialization.rs @@ -23,7 +23,7 @@ use stacks_common::util::hash::{hex_bytes, to_hex}; use stacks_common::util::retry::BoundReader; use super::{ListTypeData, TupleTypeSignature}; -use crate::errors::analysis::{CommonCheckErrorKind, StaticCheckErrorKind}; +use crate::errors::analysis::StaticCheckErrorKind; use crate::errors::{CheckErrorKind, IncomparableError, VmInternalError}; use crate::representations::{ClarityName, ContractName, MAX_STRING_LEN}; use crate::types::{ @@ -129,14 +129,6 @@ impl From for SerializationError { } } -// TODO: remove. CommonCheckErrorKind shouldn't be used in the public API. -// So there shouldn't be any need to convert it to a SerializationError. -impl From for SerializationError { - fn from(e: CommonCheckErrorKind) -> Self { - SerializationError::BadTypeError(CheckErrorKind::from(e)) - } -} - define_u8_enum!(TypePrefix { Int = 0, UInt = 1, @@ -621,8 +613,8 @@ impl Value { TypePrefix::Buffer => { let mut buffer_len = [0; 4]; r.read_exact(&mut buffer_len)?; - let buffer_len = BufferLength::try_from(u32::from_be_bytes(buffer_len))?; - + let buffer_len = BufferLength::try_from(u32::from_be_bytes(buffer_len)) + .map_err(CheckErrorKind::from)?; if let Some(x) = &expected_type { let passed_test = match x { TypeSignature::SequenceType(SequenceSubtype::BufferType( @@ -853,7 +845,8 @@ impl Value { TypePrefix::StringASCII => { let mut buffer_len = [0; 4]; r.read_exact(&mut buffer_len)?; - let buffer_len = BufferLength::try_from(u32::from_be_bytes(buffer_len))?; + let buffer_len = BufferLength::try_from(u32::from_be_bytes(buffer_len)) + .map_err(CheckErrorKind::from)?; if let Some(x) = &expected_type { let passed_test = match x { @@ -878,7 +871,8 @@ impl Value { TypePrefix::StringUTF8 => { let mut total_len = [0; 4]; r.read_exact(&mut total_len)?; - let total_len = BufferLength::try_from(u32::from_be_bytes(total_len))?; + let total_len = BufferLength::try_from(u32::from_be_bytes(total_len)) + .map_err(CheckErrorKind::from)?; let mut data: Vec = vec![0; u32::from(total_len) as usize]; diff --git a/clarity-types/src/types/signatures.rs b/clarity-types/src/types/signatures.rs index 7a716fae88e..5db9fe936d7 100644 --- a/clarity-types/src/types/signatures.rs +++ b/clarity-types/src/types/signatures.rs @@ -920,7 +920,7 @@ impl TypeSignature { } /// If one of the types is a NoType, return Ok(the other type), otherwise return least_supertype(a, b) - pub fn factor_out_no_type( + pub(crate) fn factor_out_no_type( epoch: &StacksEpochId, a: &TypeSignature, b: &TypeSignature, @@ -993,7 +993,7 @@ impl TypeSignature { } } - pub fn least_supertype_v2_0( + fn least_supertype_v2_0( a: &TypeSignature, b: &TypeSignature, ) -> Result { @@ -1102,7 +1102,7 @@ impl TypeSignature { } } - pub fn least_supertype_v2_1( + pub(crate) fn least_supertype_v2_1( a: &TypeSignature, b: &TypeSignature, ) -> Result { @@ -1289,19 +1289,18 @@ impl TypeSignature { Ok(out) } - pub fn literal_type_of(x: &Value) -> Result { + pub fn literal_type_of(x: &Value) -> Result { match x { Value::Principal(PrincipalData::Contract(contract_id)) => Ok(CallableType( CallableSubtype::Principal(contract_id.clone()), )), - _ => Self::type_of(x), + _ => Self::type_of(x).map_err(StaticCheckErrorKind::from), } } // Checks if resulting type signature is of valid size. pub fn construct_parent_list_type(args: &[Value]) -> Result { - let children_types: Result, CommonCheckErrorKind> = - args.iter().map(TypeSignature::type_of).collect(); + let children_types: Result, _> = args.iter().map(TypeSignature::type_of).collect(); Ok(TypeSignature::parent_list_type(&children_types?)?) } diff --git a/clarity/src/vm/types/signatures.rs b/clarity/src/vm/types/signatures.rs index f5f49bc796e..f68f9586a00 100644 --- a/clarity/src/vm/types/signatures.rs +++ b/clarity/src/vm/types/signatures.rs @@ -17,7 +17,7 @@ use std::collections::BTreeMap; use std::fmt; -use clarity_types::errors::analysis::CommonCheckErrorKind; +use clarity_types::errors::analysis::{CommonCheckErrorKind, StaticCheckErrorKind}; pub use clarity_types::types::signatures::{ AssetIdentifier, BufferLength, CallableSubtype, ListTypeData, SequenceSubtype, StringSubtype, StringUTF8Length, TupleTypeSignature, TypeSignature, @@ -476,7 +476,7 @@ impl TypeSignatureExt for TypeSignature { } impl FixedFunction { - pub fn total_type_size(&self) -> Result { + pub fn total_type_size(&self) -> Result { let mut function_type_size = u64::from(self.returns.type_size()?); for arg in self.args.iter() { function_type_size = @@ -487,12 +487,12 @@ impl FixedFunction { } impl FunctionSignature { - pub fn total_type_size(&self) -> Result { + pub fn total_type_size(&self) -> Result { let mut function_type_size = u64::from(self.returns.type_size()?); for arg in self.args.iter() { function_type_size = function_type_size .cost_overflow_add(u64::from(arg.type_size()?)) - .map_err(|_| CommonCheckErrorKind::CostOverflow)?; + .map_err(|_| StaticCheckErrorKind::CostOverflow)?; } Ok(function_type_size) } From a3a496ff7048bec908e77ddc200422c2b5d28749 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Wed, 5 Nov 2025 12:41:47 +0000 Subject: [PATCH 03/40] cargo fmt --- clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs | 4 +--- clarity/src/vm/analysis/type_checker/v2_1/mod.rs | 4 ++-- clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs | 4 +--- clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs | 3 +-- 4 files changed, 5 insertions(+), 10 deletions(-) diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs index 3bc0a6af6d1..d5a492d09a9 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs @@ -15,9 +15,7 @@ // along with this program. If not, see . use super::{TypeChecker, TypingContext}; -use crate::vm::analysis::errors::{ - check_argument_count, StaticCheckError, StaticCheckErrorKind, -}; +use crate::vm::analysis::errors::{check_argument_count, StaticCheckError, StaticCheckErrorKind}; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::runtime_cost; use crate::vm::representations::SymbolicExpression; diff --git a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs index 32672a3f7d9..448cd41cb2f 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs @@ -26,8 +26,8 @@ pub use self::natives::{SimpleNativeFunction, TypedNativeFunction}; use super::contexts::{TypeMap, TypingContext}; use super::ContractAnalysis; pub use crate::vm::analysis::errors::{ - check_argument_count, check_arguments_at_least, check_arguments_at_most, - StaticCheckError, StaticCheckErrorKind, SyntaxBindingErrorType, + check_argument_count, check_arguments_at_least, check_arguments_at_most, StaticCheckError, + StaticCheckErrorKind, SyntaxBindingErrorType, }; use crate::vm::analysis::AnalysisDatabase; use crate::vm::costs::cost_functions::ClarityCostFunction; diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs index b6461217d75..c00c7aaeeaf 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs @@ -17,9 +17,7 @@ use stacks_common::consts::TOKEN_TRANSFER_MEMO_LENGTH; use super::{TypeChecker, TypingContext}; -use crate::vm::analysis::errors::{ - check_argument_count, StaticCheckError, StaticCheckErrorKind, -}; +use crate::vm::analysis::errors::{check_argument_count, StaticCheckError, StaticCheckErrorKind}; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::runtime_cost; use crate::vm::representations::SymbolicExpression; diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs index ca520bced38..26e44b9aea5 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs @@ -17,8 +17,7 @@ use stacks_common::types::StacksEpochId; use crate::vm::analysis::type_checker::v2_1::{ - check_arguments_at_least, StaticCheckError, StaticCheckErrorKind, TypeChecker, - TypingContext, + check_arguments_at_least, StaticCheckError, StaticCheckErrorKind, TypeChecker, TypingContext, }; use crate::vm::costs::cost_functions::ClarityCostFunction; use crate::vm::costs::{analysis_typecheck_cost, runtime_cost}; From 2301bfeb18a7162898c02907fa2b103588806e28 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Thu, 6 Nov 2025 15:02:26 +0000 Subject: [PATCH 04/40] add first set of StaticCheckError consensus tests --- clarity-types/src/errors/analysis.rs | 4 +- stackslib/src/chainstate/tests/consensus.rs | 356 +++++++++++++++++- ...c_check_error_bad_map_type_definition.snap | 216 +++++++++++ ...s__static_check_error_bad_match_input.snap | 216 +++++++++++ ...c_check_error_bad_match_option_syntax.snap | 216 +++++++++++ ...check_error_bad_match_response_syntax.snap | 216 +++++++++++ ...heck_error_constructed_list_too_large.snap | 216 +++++++++++ ...error_could_not_determine_match_types.snap | 216 +++++++++++ ...could_not_determine_response_err_type.snap | 216 +++++++++++ ..._could_not_determine_response_ok_type.snap | 216 +++++++++++ ...k_error_define_variable_bad_signature.snap | 216 +++++++++++ ...sus__static_check_error_expected_name.snap | 216 +++++++++++ ...ic_check_error_expected_optional_type.snap | 216 +++++++++++ ...ic_check_error_expected_response_type.snap | 216 +++++++++++ ..._check_error_invalid_type_description.snap | 216 +++++++++++ ...tic_check_error_match_arms_must_match.snap | 216 +++++++++++ ..._static_check_error_name_already_used.snap | 216 +++++++++++ ...eck_error_requires_at_least_arguments.snap | 216 +++++++++++ ...c_check_error_return_types_must_match.snap | 216 +++++++++++ ...tatic_check_error_supertype_too_large.snap | 13 + ...sensus__static_check_error_type_error.snap | 216 +++++++++++ ...c_check_error_type_signature_too_deep.snap | 216 +++++++++++ ...static_check_error_undefined_variable.snap | 216 +++++++++++ ..._static_check_error_unknown_type_name.snap | 216 +++++++++++ ...tatic_check_error_value_out_of_bounds.snap | 216 +++++++++++ ...s__static_check_error_value_too_large.snap | 216 +++++++++++ 26 files changed, 5339 insertions(+), 2 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_map_type_definition.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_input.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_option_syntax.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_response_syntax.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_constructed_list_too_large.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_match_types.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_response_err_type.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_response_ok_type.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_variable_bad_signature.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_name.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_optional_type.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_response_type.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_invalid_type_description.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_match_arms_must_match.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_name_already_used.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_requires_at_least_arguments.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_return_types_must_match.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_supertype_too_large.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_type_error.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_type_signature_too_deep.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_undefined_variable.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unknown_type_name.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_value_out_of_bounds.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_value_too_large.snap diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index a5d2a11362c..b2a74f4372c 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -288,6 +288,8 @@ pub enum StaticCheckErrorKind { /// Type signature nesting depth exceeds the allowed limit during analysis. TypeSignatureTooDeep, /// Expected a name (e.g., variable, function) but found an invalid or missing token. + /// NOTE: This error is only used nested in a BadMatchOptionSyntax, BadMatchResponseSyntax, + /// or BadMatchInput. ExpectedName, /// Supertype (e.g., trait or union) exceeds the maximum allowed size or complexity. /// This error indicates a transaction would invalidate a block if included. @@ -1330,7 +1332,7 @@ impl DiagnosableError for StaticCheckErrorKind { StaticCheckErrorKind::IfArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'if' must match (got '{type_1}' and '{type_2}')"), StaticCheckErrorKind::MatchArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'match' must match (got '{type_1}' and '{type_2}')"), StaticCheckErrorKind::DefaultTypesMustMatch(type_1, type_2) => format!("expression types passed in 'default-to' must match (got '{type_1}' and '{type_2}')"), - StaticCheckErrorKind::IllegalOrUnknownFunctionApplication(function_name) => format!("use of illegal / unresolved function '{function_name}"), + StaticCheckErrorKind::IllegalOrUnknownFunctionApplication(function_name) => format!("use of illegal / unresolved function '{function_name}'"), StaticCheckErrorKind::UnknownFunction(function_name) => format!("use of unresolved function '{function_name}'"), 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(), diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index 55cc74d53cc..880176b0512 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -29,7 +29,7 @@ use clarity::util::hash::{MerkleTree, Sha512Trunc256Sum}; use clarity::util::secp256k1::MessageSignature; use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; use clarity::vm::costs::ExecutionCost; -use clarity::vm::types::PrincipalData; +use clarity::vm::types::{PrincipalData, MAX_TYPE_DEPTH}; use clarity::vm::{ClarityVersion, Value as ClarityValue, MAX_CALL_STACK_DEPTH}; use serde::{Deserialize, Serialize, Serializer}; use stacks_common::bitvec::BitVec; @@ -1169,3 +1169,357 @@ contract_deploy_consensus_test!( format!("{tx_exceeds_body_start}u1 {tx_exceeds_body_end}") }, ); + +// StaticCheckError: [`StaticCheckError::ValueTooLarge`] +// Caused by: Value exceeds the maximum allowed size for type-checking +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_value_too_large, + contract_name: "value-too-large", + contract_code: "(as-max-len? 0x01 u1048577)", +); + +// StaticCheckError: [`StaticCheckError::ValueOutOfBounds`] +// Caused by: Value is outside the acceptable range for its type +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_value_out_of_bounds, + contract_name: "value-out-of-bounds", + contract_code: "(define-private (func (x (buff -12))) (len x)) + (func 0x00)", +); + +// StaticCheckError: [`StaticCheckError::ExpectedName`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_expected_name, + contract_name: "expected-name", + contract_code: "(match (some 1) 2 (+ 1 1) (+ 3 4))", +); + +// StaticCheckError: [`StaticCheckErrorKind::ExpectedResponseType`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_expected_response_type, + contract_name: "expected-response-type", + contract_code: "(unwrap-err! (some 2) 2)", +); + +// StaticCheckError: [`StaticCheckErrorKind::CouldNotDetermineResponseOkType`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_could_not_determine_response_ok_type, + contract_name: "could-not-determine", + contract_code: "(unwrap! (err 3) 2)", +); + +// StaticCheckError: [`StaticCheckErrorKind::CouldNotDetermineResponseErrType`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_could_not_determine_response_err_type, + contract_name: "could-not-determine", + contract_code: "(unwrap-err-panic (ok 3))", +); + +// StaticCheckError: [`StaticCheckErrorKind::CouldNotDetermineMatchTypes`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_could_not_determine_match_types, + contract_name: "could-not-determine", + contract_code: "(match none inner-value (/ 1 0) (+ 1 8))", +); + +// StaticCheckError: [`StaticCheckErrorKind::MatchArmsMustMatch`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_match_arms_must_match, + contract_name: "match-arms-must-match", + contract_code: "(match (some 1) inner-value (+ 1 inner-value) (> 1 28))", +); + +// StaticCheckError: [`StaticCheckErrorKind::BadMatchOptionSyntax`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_bad_match_option_syntax, + contract_name: "bad-match-option", + contract_code: "(match (some 1) inner-value (+ 1 inner-value))", +); + +// StaticCheckError: [`StaticCheckErrorKind::BadMatchResponseSyntax`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_bad_match_response_syntax, + contract_name: "bad-match-response", + contract_code: "(match (ok 1) inner-value (+ 1 inner-value))", +); + +// StaticCheckError: [`StaticCheckErrorKind::RequiresAtLeastArguments`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_requires_at_least_arguments, + contract_name: "requires-at-least", + contract_code: "(match)", +); + +// StaticCheckError: [`StaticCheckErrorKind::BadMatchInput`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_bad_match_input, + contract_name: "bad-match-input", + contract_code: "(match 1 ok-val (/ ok-val 0) err-val (+ err-val 7))", +); + +// StaticCheckError: [`StaticCheckErrorKind::ExpectedOptionalType`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_expected_optional_type, + contract_name: "expected-optional-type", + contract_code: "(default-to 3 5)", +); + +// StaticCheckError: [`StaticCheckErrorKind::NameAlreadyUsed`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_name_already_used, + contract_name: "name-already-used", + contract_code: " + (define-constant foo 10) + (define-constant foo 20)", +); + +// StaticCheckError: [`StaticCheckErrorKind::ReturnTypesMustMatch`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_return_types_must_match, + contract_name: "return-types-must", + contract_code: " + (define-map tokens { id: int } { balance: int }) + (define-private (my-get-token-balance) + (let ((balance (unwrap! + (get balance (map-get? tokens (tuple (id 0)))) + (err 1)))) + (err false)))", +); + +// StaticCheckError: [`StaticCheckErrorKind::TypeError`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_type_error, + contract_name: "type-error", + contract_code: "(define-data-var cursor int true)", +); + +// StaticCheckError: [`StaticCheckErrorKind::DefineVariableBadSignature`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_define_variable_bad_signature, + contract_name: "define-variable-bad", + contract_code: "(define-data-var cursor 0x00)", +); + +// StaticCheckError: [`StaticCheckErrorKind::InvalidTypeDescription`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_invalid_type_description, + contract_name: "invalid-type-desc", + contract_code: "(define-data-var cursor 0x00 true)", +); + +// StaticCheckError: [`StaticCheckErrorKind::TypeSignatureTooDeep`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_type_signature_too_deep, + contract_name: "signature-too-deep", + contract_code: &{ + let depth: usize = MAX_TYPE_DEPTH as usize + 1; + let mut s = String::from("(define-public (f (x "); + for _ in 0..depth { + s.push_str("(optional "); + } + s.push_str("uint"); + for _ in 0..depth { + s.push_str(") "); + } + s.push_str(")) (ok x))"); + s + }, +); + +// StaticCheckError: [`StaticCheckErrorKind::SupertypeTooLarge`] +// Caused by: +// Outcome: block rejected. +contract_deploy_consensus_test!( + static_check_error_supertype_too_large, + contract_name: "supertype-too-large", + contract_code: " + (define-data-var big (buff 600000) 0x00) + (define-data-var small (buff 10) 0x00) + (define-public (trigger) + (let ((initial (list (tuple (a (var-get big)) (b (var-get small)))))) + (ok (append initial (tuple (a (var-get small)) (b (var-get big)))))))", +); + +// StaticCheckError: [`StaticCheckErrorKind::ConstructedListTooLarge`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_constructed_list_too_large, + contract_name: "constructed-list-large", + contract_code: " + (define-data-var ints (list 65535 int) (list 0)) + (define-public (trigger) + (let ((mapped (map sha512 (var-get ints)))) + (ok mapped) + ) + )", +); + +// StaticCheckError: [`StaticCheckErrorKind::UnknownTypeName`] +// Caused by: +// Outcome: block accepted. +// Note: during analysis, this error can only be triggered by `from-consensus-buff?` +// which is only available in Clarity 2 and later. So Clarity 1 will not trigger +// this error. +contract_deploy_consensus_test!( + static_check_error_unknown_type_name, + contract_name: "unknown-type-name", + contract_code: " + (define-public (trigger) + (ok (from-consensus-buff? foo 0x00)))", +); + +// StaticCheckError: [`StaticCheckErrorKind::UndefinedVariable`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_undefined_variable, + contract_name: "undefined-variable", + contract_code: "(+ x y z)", +); + +// StaticCheckError: [`StaticCheckErrorKind::BadMapTypeDefinition`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_bad_map_type_definition, + contract_name: "bad-map-type", + contract_code: "(define-map lists { name: int } contents)", +); + +// pub enum StaticCheckErrorKind { +// CostOverflow, +// CostBalanceExceeded(ExecutionCost, ExecutionCost), +// MemoryBalanceExceeded(u64, u64), +// CostComputationFailed(String), +// ExecutionTimeExpired, +// ValueTooLarge, [`static_check_error_value_too_large`] +// ValueOutOfBounds, [`static_check_error_value_out_of_bounds`] +// TypeSignatureTooDeep, [`static_check_error_type_signature_too_deep`] +// ExpectedName, [`static_check_error_expected_name`] +// SupertypeTooLarge, [`static_check_error_supertype_too_large`] +// Expects(String), +// BadMatchOptionSyntax(Box), [`static_check_error_bad_match_option_syntax`] +// BadMatchResponseSyntax(Box), [`static_check_error_bad_match_response_syntax`] +// BadMatchInput(Box), [`static_check_error_bad_match_input`] +// ConstructedListTooLarge, [`static_check_error_constructed_list_too_large`] +// TypeError(Box, Box), [`static_check_error_type_error`] +// InvalidTypeDescription, [`static_check_error_invalid_type_description`] +// UnknownTypeName(String), [`static_check_error_unknown_type_name`] +// UnionTypeError(Vec, Box), +// ExpectedOptionalType(Box), [`static_check_error_expected_optional_type`] +// ExpectedResponseType(Box), [`static_check_error_expected_response_type`] +// ExpectedOptionalOrResponseType(Box), +// CouldNotDetermineResponseOkType, [`static_check_error_could_not_determine_response_ok_type`] +// CouldNotDetermineResponseErrType, [`static_check_error_could_not_determine_response_err_type`] +// CouldNotDetermineSerializationType, +// UncheckedIntermediaryResponses, +// CouldNotDetermineMatchTypes, [`static_check_error_could_not_determine_match_types`] +// CouldNotDetermineType, +// TypeAlreadyAnnotatedFailure, +// CheckerImplementationFailure, +// BadTokenName, +// DefineNFTBadSignature, +// NoSuchNFT(String), +// NoSuchFT(String), +// BadTupleFieldName, +// ExpectedTuple(Box), +// NoSuchTupleField(String, TupleTypeSignature), +// EmptyTuplesNotAllowed, +// BadTupleConstruction(String), +// NoSuchDataVariable(String), +// BadMapName, +// NoSuchMap(String), +// DefineFunctionBadSignature, +// BadFunctionName, +// BadMapTypeDefinition, [`static_check_error_bad_map_type_definition`] +// PublicFunctionMustReturnResponse(Box), +// DefineVariableBadSignature, [`static_check_error_define_variable_bad_signature`] +// ReturnTypesMustMatch(Box, Box), +// NoSuchContract(String), +// NoSuchPublicFunction(String, String), +// ContractAlreadyExists(String), +// ContractCallExpectName, +// ExpectedCallableType(Box), +// NoSuchBlockInfoProperty(String), +// NoSuchStacksBlockInfoProperty(String), +// NoSuchTenureInfoProperty(String), +// GetBlockInfoExpectPropertyName, +// GetBurnBlockInfoExpectPropertyName, +// GetStacksBlockInfoExpectPropertyName, +// GetTenureInfoExpectPropertyName, +// NameAlreadyUsed(String), [`static_check_error_name_already_used`] +// ReservedWord(String), +// NonFunctionApplication, +// ExpectedListApplication, +// ExpectedSequence(Box), +// MaxLengthOverflow, +// BadLetSyntax, +// BadSyntaxBinding(SyntaxBindingError), +// MaxContextDepthReached, +// UndefinedVariable(String), +// RequiresAtLeastArguments(usize, usize), [`static_check_error_requires_at_least_arguments`] +// RequiresAtMostArguments(usize, usize), +// IncorrectArgumentCount(usize, usize), +// IfArmsMustMatch(Box, Box), +// MatchArmsMustMatch(Box, Box), [`static_check_error_match_arms_must_match`] +// DefaultTypesMustMatch(Box, Box), +// IllegalOrUnknownFunctionApplication(String), +// UnknownFunction(String), +// NoSuchTrait(String, String), +// TraitReferenceUnknown(String), +// TraitMethodUnknown(String, String), +// ExpectedTraitIdentifier, +// BadTraitImplementation(String, String), +// DefineTraitBadSignature, +// DefineTraitDuplicateMethod(String), +// UnexpectedTraitOrFieldReference, +// ContractOfExpectsTrait, +// IncompatibleTrait(Box, Box), +// WriteAttemptedInReadOnly, +// AtBlockClosureMustBeReadOnly, +// ExpectedListOfAllowances(String, i32), +// AllowanceExprNotAllowed, +// ExpectedAllowanceExpr(String), +// WithAllAllowanceNotAllowed, +// WithAllAllowanceNotAlone, +// WithNftExpectedListOfIdentifiers, +// MaxIdentifierLengthExceeded(u32, u32), +// TooManyAllowances(usize, usize), +// } diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_map_type_definition.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_map_type_definition.snap new file mode 100644 index 00000000000..8408659989a --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_map_type_definition.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "2ecd86defc6de10d6515f8de1c43c6d17802f409bd93ad445d7ca35a547bc44b", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-type-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid map definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bcc385be5f182089ab65c158423733f18ab76e8a39aaeb0d6135792f68ed0aca", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-type-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid map definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "215bcb3ec1087d2ec9f6194d5531fd747abf8fdc3d3f4dd308d808c2f2e0f081", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-type-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid map definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3362860aa4daba98bfc71ade1c97b6486641efc3d6d9766ac37f2801cddc9adc", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-type-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid map definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e5226132580df1ebc4d1e4d5b0a8db9a41de39ef9379dde0224d41e8c72d269a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-type-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid map definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b1375a51953379f47e9e7df29bd1c94bfcd718add07e9460a9a0b7419f3a0cb7", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-type-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid map definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "cd1e4fda29c8e2520080b607e28b1b542c169cf79517fc04a0c5433b35fd0124", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-type-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: invalid map definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1372, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_input.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_input.snap new file mode 100644 index 00000000000..97851229c19 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_input.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "e24e5dc2a1dba6b822ae9cdc5fc601015617454217e4e8e303be952d9d043007", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-input-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: match requires an input of either a response or optional, found input: \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c5e60a48150d519d79bcb39b223ca2fd27e7aefc0e131cb3e2f7ea48b14e3e6f", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-input-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: match requires an input of either a response or optional, found input: \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2b17d111cc57c777a0d70c6336546fef9a565d27e517afc9b4cc0c7413366251", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-input-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: match requires an input of either a response or optional, found input: \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c453d0b23116174bd909b10334a8c7948631b4ea220c9745a1495977d7f6acbe", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-input-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: match requires an input of either a response or optional, found input: \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0aea2f340744445be13bad754380acde22b77056b54fd01c59aae6ba017261ef", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-input-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: match requires an input of either a response or optional, found input: \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6bd043066761e2c1167d11b77f370233c34a7a525661ee7f01e27c5b848b6bca", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-input-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: match requires an input of either a response or optional, found input: \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7a2847ffda222e45c3743586af72312cc72cb8809f05e09f0040f7ee1ea6c5a2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-input-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: match requires an input of either a response or optional, found input: \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 14, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1662, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_option_syntax.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_option_syntax.snap new file mode 100644 index 00000000000..19aa69b730b --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_option_syntax.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "9d578659db0d60582e0d0c2350b397495bc82815f341e1325694a87eefbc93e7", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-option-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expecting 4 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c031ef2e1d195f01bd76d036b82660cdfc2adc051a1e39dd3f42081668a856a1", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-option-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expecting 4 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "cc001baa7c0f0b349a53fc2f9e068b772bf3360a811f3bbfc3c56a88c606d40b", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-option-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expecting 4 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2c6755c637f031ded32234ac232fc57590210814b20a326a25e89bb9f39621ba", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-option-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expecting 4 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "10601984530e9304d232b925782ae52b32ed1198f5bbd3487a632cffb4f01fc0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-option-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expecting 4 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4160dd47e4c51379abe3da84b3a787025c5b36e1ceb76d1328c4020777a7ae7a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-option-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expecting 4 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f6cf1b035d84094ccd41d311681c61e632ec7d61434638495dd8f97a0cc12500", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-option-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expecting 4 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1538, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_response_syntax.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_response_syntax.snap new file mode 100644 index 00000000000..d65070682ac --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_match_response_syntax.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "e5ee4f96a25bb1f5e4a59c34c2687e6152b24bf69efa56c75f0cf9c0adcee119", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-response-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: match on a result type uses the following syntax: (match input ok-name if-ok-expression err-name if-err-expression). Caused by: expecting 5 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "341edf5ee497a724f599afc58d19bbd591aa40f725cbe7ac644c0a8310f7915f", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-response-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: match on a result type uses the following syntax: (match input ok-name if-ok-expression err-name if-err-expression). Caused by: expecting 5 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b450bbf2fe06560916f9ba191e85352f68f50b22cac1b9290ce1ccc79c2c4c33", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-response-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: match on a result type uses the following syntax: (match input ok-name if-ok-expression err-name if-err-expression). Caused by: expecting 5 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1426e51a3521cf1a72715fb42dd9c86014818d4eaa0158baef16c049c09996cb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-response-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: match on a result type uses the following syntax: (match input ok-name if-ok-expression err-name if-err-expression). Caused by: expecting 5 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "32135c0cb23b123439bde7f272d7dc5d0f7ae7c1e6c8b2f48b5bc75ca047b4c1", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-response-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: match on a result type uses the following syntax: (match input ok-name if-ok-expression err-name if-err-expression). Caused by: expecting 5 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d1702cb13f480d6c618bed520e83ba8614a31e18b2e7f3a0ab123f5720d6541a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-response-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: match on a result type uses the following syntax: (match input ok-name if-ok-expression err-name if-err-expression). Caused by: expecting 5 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5a58135a4e50dae40c0f35e1ba125f439db9d34aa78ce0fd2e4d093aa0d4dacd", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-match-response-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: match on a result type uses the following syntax: (match input ok-name if-ok-expression err-name if-err-expression). Caused by: expecting 5 arguments, got 3) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1485, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_constructed_list_too_large.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_constructed_list_too_large.snap new file mode 100644 index 00000000000..6bfe07a6985 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_constructed_list_too_large.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "8d627e6d3382874c193aa21bd2ddef9ba7e470d470148985958c687409a55ea1", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: constructed-list-large-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: reached limit of elements in a sequence) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7437, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7437, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b5d3fa7bb7490158e0e5789dde64e44a1b9012085d546872994b660c42c0b07c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: constructed-list-large-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: reached limit of elements in a sequence) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7436, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7436, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3bb9dea19261b12c8cdfa26ebb88c6410d490f07d4c86ec2b6f1f2faa0ce2d9b", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: constructed-list-large-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: reached limit of elements in a sequence) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7436, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7436, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8220ed0bc7c880469030abcf0bc1c4d5f4bae9b882d0bc8899395a94df4c6d24", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: constructed-list-large-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: reached limit of elements in a sequence) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7437, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7437, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "054bb35d9b3cd70af9e48c112e48d03d23e0b4d658918ab60f59e4d57fbd0dd4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: constructed-list-large-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: reached limit of elements in a sequence) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7436, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7436, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8c2b8e3c0e6755a5345f0b4f59857671ec5e2010ca6e40e696b807d59a0815fa", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: constructed-list-large-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: reached limit of elements in a sequence) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7436, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7436, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9374ccb0b4d3f7b26b1d6648577970d8d2f61175320ddf56b72edb2601b6042c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: constructed-list-large-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: reached limit of elements in a sequence) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7436, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 29, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7436, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_match_types.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_match_types.snap new file mode 100644 index 00000000000..b3eef936254 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_match_types.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "f96b95048904ee4a145d4bf749023b49ed964f22b2eafd5b273226005e78c861", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: attempted to match on an (optional) or (response) type where either the some, ok, or err type is indeterminate. you may wish to use unwrap-panic or unwrap-err-panic instead.) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "80000de3ee7d66e6625279689d0506f9be9fdc58b27d7c009e652bf8952863da", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: attempted to match on an (optional) or (response) type where either the some, ok, or err type is indeterminate. you may wish to use unwrap-panic or unwrap-err-panic instead.) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2dea0e7ae4ec0a451f16a3a184af425912dc05e7f292ec9f42b36222500a4ef1", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: attempted to match on an (optional) or (response) type where either the some, ok, or err type is indeterminate. you may wish to use unwrap-panic or unwrap-err-panic instead.) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b9dd0ee6d4f124dda68443c855bb671954e2835ee593916a963c05cebb9a2f0b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: attempted to match on an (optional) or (response) type where either the some, ok, or err type is indeterminate. you may wish to use unwrap-panic or unwrap-err-panic instead.) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7173b6f54f6dab0415e6394737293ca38335858af746d952a11919c2f18db162", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: attempted to match on an (optional) or (response) type where either the some, ok, or err type is indeterminate. you may wish to use unwrap-panic or unwrap-err-panic instead.) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "91621a33de38a28a8e6613e43fec77daa5107703c73cb85213c834376534e939", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: attempted to match on an (optional) or (response) type where either the some, ok, or err type is indeterminate. you may wish to use unwrap-panic or unwrap-err-panic instead.) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a43534969afecf1c924306c01ab4d9bb0efb3e320db971d9604cfc4928687698", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: attempted to match on an (optional) or (response) type where either the some, ok, or err type is indeterminate. you may wish to use unwrap-panic or unwrap-err-panic instead.) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1379, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_response_err_type.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_response_err_type.snap new file mode 100644 index 00000000000..dca3e8c55c2 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_response_err_type.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5ad517322daee7a5aaca3c7cbbc0bcdefa9a3445e082cd183f627f5bc844e123", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: attempted to obtain \'err\' value from response, but \'err\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "31d278804af8946a0569a0c600cface8cae1800ab85a4bd42030f293829e36b3", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: attempted to obtain \'err\' value from response, but \'err\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6425fa6b2831ceda4234543736c8596ba2089e2e256ba007f943d1671c07ecbe", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: attempted to obtain \'err\' value from response, but \'err\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "885d8eb9418e92aed2a23f687ef212467bf180a3a6db9122379beee2a28a3c14", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: attempted to obtain \'err\' value from response, but \'err\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4116b8c4d0fef912dece04c6fe52ce0f85f445d54fdfbceee531c9ebdcd24854", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: attempted to obtain \'err\' value from response, but \'err\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9bdbf51cee7221e7f146e11f567ab2e61cc9cc64c2b349f3a25776342a29c69f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: attempted to obtain \'err\' value from response, but \'err\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1c5d1b3aa4e92af5c3abdd7663eb343d0070a7008d252a52976e27d8c7d9b5ba", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: attempted to obtain \'err\' value from response, but \'err\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 966, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_response_ok_type.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_response_ok_type.snap new file mode 100644 index 00000000000..16b9ad640bd --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_response_ok_type.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "d696f9e3001bc26426552d727c8df876f826c6ee62de3bdd271a588ea636c30c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: attempted to obtain \'ok\' value from response, but \'ok\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c1b3efe4d67331570aba23a38b90471ca9a6a4eaa2fc536975e7db58b909e042", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: attempted to obtain \'ok\' value from response, but \'ok\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b26050497517e265e84d62717e56ce22b83e394a6bb846f427113c0f011669be", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: attempted to obtain \'ok\' value from response, but \'ok\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "19623da1d1c58eb71a73ab4c8e10a1a7d8db0131ca32b09e89e7d88e6c24b1a0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: attempted to obtain \'ok\' value from response, but \'ok\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "43984fbc202a2773ada998f14b31b0aa7eed0b7d67d57aa69e860852aa8a88bc", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: attempted to obtain \'ok\' value from response, but \'ok\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8a8fd6ce5ceb10aa35546edd2499d7ea254d97bbdb200fdec5372c4ce97d1c1b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: attempted to obtain \'ok\' value from response, but \'ok\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7813a3446b6c8ff9c99eb29773dd589f005d95789364cef83f83d7e8efcb9ad9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: attempted to obtain \'ok\' value from response, but \'ok\' type is indeterminate) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 931, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_variable_bad_signature.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_variable_bad_signature.snap new file mode 100644 index 00000000000..b292481b694 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_variable_bad_signature.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "7f15bb069bea6c767d55397e51f6d764a13e6173b004fa4d2431dcd70fc8d15c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: define-variable-bad-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting 3 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "efa2cceb1acc7c33fbc49fcb8aa1008140b04106c51bf78b4556e5277ba10759", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: define-variable-bad-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting 3 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2d76ebe360d51fb2e4f026b7c38f4d64348af1d4580d0f884c52dbf2c7ff793e", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: define-variable-bad-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting 3 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d850a2557732db40628e72c55a559dc41175deacf6aecc532a4aff26f620d3dd", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: define-variable-bad-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting 3 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8e22c82b0a43cde3b221bfbd508f010fe43e1d1f187b021f3311e87f2c1cfedd", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: define-variable-bad-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting 3 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "14296ed247011ca2b4c153316deb64db310647f616a8b3ebfab824c209878707", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: define-variable-bad-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting 3 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ab41141cda3d7effb003097cefefc767cd7f2c34d0308036250cb796d8ba3f77", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: define-variable-bad-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting 3 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 936, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_name.snap new file mode 100644 index 00000000000..fa060cb4cd8 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_name.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "6c07c6f4a33fe0591307018d79f917c13aa4ba6fe6af53fef764b14a85810a95", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expected a name argument to this function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3f2434a02ef003989e9a3447f9ff632407c8a98b400b258c02995625a8accae0", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expected a name argument to this function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d94a69dd539efdb2294021dad9a3f5d9351842707054236f8df64f47b2cb380a", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expected a name argument to this function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7b5ea9119e432d057b0441c8a186307826c34a21c27f403416b22cf825f770fd", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expected a name argument to this function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4051c33775ed70fdf7d5157cefa6be169b7701095a97ce41d9c64d362d7687f5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expected a name argument to this function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "27c008b080fdf2d158d45ab66a19de51136ae016f298088ccacd9ab1a971dca9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expected a name argument to this function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "dd825777f40039516238dc8a6d8719f90d7b4bdd09eed54fbbc310fdd4d069a5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: expected a name argument to this function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1222, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_optional_type.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_optional_type.snap new file mode 100644 index 00000000000..2a7311646c0 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_optional_type.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5ba074a74da014e52ff1a01d1058774e6968b715ae3c20db1c2eaf82b5f098d6", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-optional-type-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'optional\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f354f57d8e4aa58115778dcd796bddf9778f28da320a366e1fd880b9cf158844", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-optional-type-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'optional\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "21e697254e1a2294826b9320d68060fc6521c10c02c700fcc049494d20da8438", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-optional-type-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'optional\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d46d52467a4ef221f512f8431e30c6bc82e6b820e75a8cce20403b7592d84611", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-optional-type-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'optional\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "76bf2c2ed403675e0d5ab5deae8ca1c45dde4cb8da5365ababd62f22391ae66a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-optional-type-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'optional\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "37ff4131c80359c0855d53ab15fdc5e84ca94b4769e40f64ff7a182b7581410c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-optional-type-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'optional\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ece76e15b4342c283b808f925f055c92f71ac00cdad3033d3c8db8896574613d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-optional-type-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting expression of type \'optional\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 824, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_response_type.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_response_type.snap new file mode 100644 index 00000000000..d2ca074fa62 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_response_type.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "503019f3be7848862c59c2c95182cf38f978d976e72025075e64bab14cb2af93", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-response-type-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'response\', found \'(optional int)\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a031ad304f5b05810e9ba842798b65d36460425175b387eab4b788ab5159f73e", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-response-type-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'response\', found \'(optional int)\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6945db684d3347b0b227ae0b74fbefbbd4338074eb9b48fbab1793ca04527665", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-response-type-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'response\', found \'(optional int)\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "68217c0bdb7f9ef47c726d63b0ff35bdceb109a2464570231826c7e67e3b754d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-response-type-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'response\', found \'(optional int)\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f4353e47b5e17d6c9eb94dd0fd4fd01205888ac71b6718d1c25a6d77d5f4f82e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-response-type-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'response\', found \'(optional int)\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f078e4d5de24d424b31c9563db9ca6429805bc4bef814fb3bb7d48450475a3a5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-response-type-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'response\', found \'(optional int)\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7248e470edca2f7a81701cecee3fa3794b8793014af3cc70341e052049c7599c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-response-type-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting expression of type \'response\', found \'(optional int)\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1065, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_invalid_type_description.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_invalid_type_description.snap new file mode 100644 index 00000000000..c4619170cd6 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_invalid_type_description.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "6c07c6f4a33fe0591307018d79f917c13aa4ba6fe6af53fef764b14a85810a95", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: invalid-type-desc-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid variable definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e78ba2cbbba27c0004361df765313623326d5c169dd386820435439bdeb42587", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: invalid-type-desc-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid variable definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6d0f24139d39c8c0e805f52751447c8bbebbce7323af07cb600eb2f5af559f53", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: invalid-type-desc-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid variable definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "235c704891cc2af0726903cc287ef539ef9e5c3b2d4c20d6585470edeed702b6", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: invalid-type-desc-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid variable definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3a08d05ea743022bbba0cb8bba173be85c9751f5ec433b8dd8556553c7389488", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: invalid-type-desc-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid variable definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "63ccd683ac1abd6aeafdf00bb5dcc988bab7ff3a5114ef6e4c2705cd3ebbb36a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: invalid-type-desc-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid variable definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bd5d4b3a9f50d6a5a8eda28cff0dc4138d15eed430d289e595290fbbb669ea81", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: invalid-type-desc-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: invalid variable definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1175, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_match_arms_must_match.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_match_arms_must_match.snap new file mode 100644 index 00000000000..b475d0ced8c --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_match_arms_must_match.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "95d025937ea27ea56620a993bc7e7f9792952ce66e5822710e782b6b40a76cb5", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: match-arms-must-match-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expression types returned by the arms of \'match\' must match (got \'int\' and \'bool\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e99b7ce7e3f2282fc32ee2e150e0aec0dd1bceb935cd3a3000ed76d48613b32b", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: match-arms-must-match-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expression types returned by the arms of \'match\' must match (got \'int\' and \'bool\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b46a4152ae064d75d1736c2a8c122566e104d7a3eb393776e3d30e9a63f11d3d", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: match-arms-must-match-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expression types returned by the arms of \'match\' must match (got \'int\' and \'bool\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6d8b85dc634781545e17d357e8815206aeed57c51ad3e76524ea5d85dc36eb5d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: match-arms-must-match-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expression types returned by the arms of \'match\' must match (got \'int\' and \'bool\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a8035a20a371c5c8850310fc50a6e6463222f145511191992c4b4973e8a92c1b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: match-arms-must-match-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expression types returned by the arms of \'match\' must match (got \'int\' and \'bool\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d22004a540bc022b9a81eb917e3b553a64cc36870ec63b7c1b63ea31167f10ba", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: match-arms-must-match-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expression types returned by the arms of \'match\' must match (got \'int\' and \'bool\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9cf099d08219e2fb369e6dd6de5e7a635ce29346a2963f15636677e882950737", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: match-arms-must-match-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expression types returned by the arms of \'match\' must match (got \'int\' and \'bool\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 15, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2512, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_name_already_used.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_name_already_used.snap new file mode 100644 index 00000000000..8a76db4d9aa --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_name_already_used.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "bac3f91272f70bddd13b04c59ae408ef7c070bc6348f41e60bb7730dae8d8ea5", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: defining \'foo\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "22d8f2dad723bf6f978a1b421a99c614b85299dd961a3800375468f3d968a6e6", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: defining \'foo\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0ab6d778c44350677ce46f9de2be6f1398a916b3eb0d7af58e4fbee829e4807c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: defining \'foo\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d4fd0885cd09cc67848b31c14904450a14f5eac08f31b871f44218c323d44fcc", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: defining \'foo\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c2774a0aec1496ff71c16166a30d498f28717146d621823a6d2613bc0aa896e4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: defining \'foo\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7dcd3abf55b1e71ecf7f98529757fc8acf1308182b815619cc99e6fab016dfd3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: defining \'foo\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "cc0566e8e605850d1d6a83356b9a69e893c37192f2aaafc4910e6c1d1170caf2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: defining \'foo\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2187, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_requires_at_least_arguments.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_requires_at_least_arguments.snap new file mode 100644 index 00000000000..a9aa745c115 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_requires_at_least_arguments.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "d24d8e0f69f6ac54831eeb7e091647e999cbc1479c1b0b81592b87fe2d5afc99", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-least-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting >= 1 arguments, got 0) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4537b994f20eca6edf9f701aea6113692c1be801f17a58aa917ee6112038ca25", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-least-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting >= 1 arguments, got 0) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "372c8b7595a4d5641326d21df5cb8f3d019dfda067e31afb69724b3aacbe28cb", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-least-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting >= 1 arguments, got 0) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9b4bc827cb30612a00ae1092995ca322c8865dd074cef764c69254d16f4d8815", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-least-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting >= 1 arguments, got 0) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5311ff7be45c169dc2dbd9af6af7dacab11e535dcf4c3c49c7fa036e9617b112", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-least-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting >= 1 arguments, got 0) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7018c8af7d1793a53f4f42bdb539330c617e8172342a59e3c65207d8868f9fb4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-least-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting >= 1 arguments, got 0) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6ed5a2df83603758d59f6afc94c91c538dbbf97938a75dcc489472e7e6f09ec8", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-least-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting >= 1 arguments, got 0) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 3, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 441, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_return_types_must_match.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_return_types_must_match.snap new file mode 100644 index 00000000000..c397c8b60ec --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_return_types_must_match.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "bc75a4635504c45376ca2698a41dc218fa404a371b23a913be3025bbd680fd67", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: return-types-must-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: detected two execution paths, returning two different expression types (got \'(response UnknownType int)\' and \'(response UnknownType bool)\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b2e2e5b4d07c846e212f0720444a146e0021e886220d02071c7bde1c0b7dd7fd", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: return-types-must-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: detected two execution paths, returning two different expression types (got \'(response UnknownType int)\' and \'(response UnknownType bool)\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b182a7f41e9dd01d2e2413edd26d307b8d6afae4ebd1e910136c4b2094db4db3", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: return-types-must-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: detected two execution paths, returning two different expression types (got \'(response UnknownType int)\' and \'(response UnknownType bool)\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "167caf70ec1c7709b95e7d713b39c9f3e3cf4a28999fceb4651452f126507b4a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: return-types-must-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: detected two execution paths, returning two different expression types (got \'(response UnknownType int)\' and \'(response UnknownType bool)\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "96d78068870bf13e0424d76a653393b7dc6b82328570074be83182cdcd3d261c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: return-types-must-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: detected two execution paths, returning two different expression types (got \'(response UnknownType int)\' and \'(response UnknownType bool)\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "034962dcce602d51d0aa85d2ee38206b615ae46c9685170000c2fb89e74d7a21", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: return-types-must-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: detected two execution paths, returning two different expression types (got \'(response UnknownType int)\' and \'(response UnknownType bool)\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ddefbeed3e551145b8c6f533d5c37feeaaa39d05a81f1b9edf81ecd240a5b1fe", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: return-types-must-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: detected two execution paths, returning two different expression types (got \'(response UnknownType int)\' and \'(response UnknownType bool)\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 42, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 9463, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_supertype_too_large.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_supertype_too_large.snap new file mode 100644 index 00000000000..c8a53f36cda --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_supertype_too_large.snap @@ -0,0 +1,13 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Failure("Invalid Stacks block e7413ee9ea33d614801a07507f124a9f441481fc1245d06d199799e7df3de907: ClarityError(StaticCheck(StaticCheckError { err: SupertypeTooLarge, expressions: Some([SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"append\")), id: 41 }, SymbolicExpression { expr: Atom(ClarityName(\"initial\")), id: 42 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"tuple\")), id: 44 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"a\")), id: 46 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 48 }, SymbolicExpression { expr: Atom(ClarityName(\"small\")), id: 49 }]), id: 47 }]), id: 45 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"b\")), id: 51 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 53 }, SymbolicExpression { expr: Atom(ClarityName(\"big\")), id: 54 }]), id: 52 }]), id: 50 }]), id: 43 }]), id: 40 }]), diagnostic: Diagnostic { level: Error, message: \"supertype of two types is too large\", spans: [Span { start_line: 0, start_column: 0, end_line: 0, end_column: 0 }], suggestion: None } }))"), + Failure("Invalid Stacks block ae322d90843d97b85a01516b08b4bde4daeb5ecd3b912e4ce3b2696dbe0e7b07: ClarityError(StaticCheck(StaticCheckError { err: SupertypeTooLarge, expressions: Some([SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"append\")), id: 41 }, SymbolicExpression { expr: Atom(ClarityName(\"initial\")), id: 42 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"tuple\")), id: 44 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"a\")), id: 46 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 48 }, SymbolicExpression { expr: Atom(ClarityName(\"small\")), id: 49 }]), id: 47 }]), id: 45 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"b\")), id: 51 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 53 }, SymbolicExpression { expr: Atom(ClarityName(\"big\")), id: 54 }]), id: 52 }]), id: 50 }]), id: 43 }]), id: 40 }]), diagnostic: Diagnostic { level: Error, message: \"supertype of two types is too large\", spans: [Span { start_line: 0, start_column: 0, end_line: 0, end_column: 0 }], suggestion: None } }))"), + Failure("Invalid Stacks block 92b493ce208409980f78888ced5c34b5fb9192dbc8b4a08ee8803f17f8876ab3: ClarityError(StaticCheck(StaticCheckError { err: SupertypeTooLarge, expressions: Some([SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"append\")), id: 41 }, SymbolicExpression { expr: Atom(ClarityName(\"initial\")), id: 42 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"tuple\")), id: 44 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"a\")), id: 46 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 48 }, SymbolicExpression { expr: Atom(ClarityName(\"small\")), id: 49 }]), id: 47 }]), id: 45 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"b\")), id: 51 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 53 }, SymbolicExpression { expr: Atom(ClarityName(\"big\")), id: 54 }]), id: 52 }]), id: 50 }]), id: 43 }]), id: 40 }]), diagnostic: Diagnostic { level: Error, message: \"supertype of two types is too large\", spans: [Span { start_line: 0, start_column: 0, end_line: 0, end_column: 0 }], suggestion: None } }))"), + Failure("Invalid Stacks block ca5144f4e828ed9d84477bed1d69de5e079beb0c31bcd5ac1a8f6d055233ba9a: ClarityError(StaticCheck(StaticCheckError { err: SupertypeTooLarge, expressions: Some([SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"append\")), id: 41 }, SymbolicExpression { expr: Atom(ClarityName(\"initial\")), id: 42 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"tuple\")), id: 44 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"a\")), id: 46 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 48 }, SymbolicExpression { expr: Atom(ClarityName(\"small\")), id: 49 }]), id: 47 }]), id: 45 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"b\")), id: 51 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 53 }, SymbolicExpression { expr: Atom(ClarityName(\"big\")), id: 54 }]), id: 52 }]), id: 50 }]), id: 43 }]), id: 40 }]), diagnostic: Diagnostic { level: Error, message: \"supertype of two types is too large\", spans: [Span { start_line: 0, start_column: 0, end_line: 0, end_column: 0 }], suggestion: None } }))"), + Failure("Invalid Stacks block 4c5bfde510ea28de9ef2fa1b8c644fccf9d4bb99cd63c7cf9d1a89f8f5a89ab5: ClarityError(StaticCheck(StaticCheckError { err: SupertypeTooLarge, expressions: Some([SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"append\")), id: 41 }, SymbolicExpression { expr: Atom(ClarityName(\"initial\")), id: 42 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"tuple\")), id: 44 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"a\")), id: 46 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 48 }, SymbolicExpression { expr: Atom(ClarityName(\"small\")), id: 49 }]), id: 47 }]), id: 45 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"b\")), id: 51 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 53 }, SymbolicExpression { expr: Atom(ClarityName(\"big\")), id: 54 }]), id: 52 }]), id: 50 }]), id: 43 }]), id: 40 }]), diagnostic: Diagnostic { level: Error, message: \"supertype of two types is too large\", spans: [Span { start_line: 0, start_column: 0, end_line: 0, end_column: 0 }], suggestion: None } }))"), + Failure("Invalid Stacks block df02c29bb936e21d786ec2927c41a55735a13976dc41afac047e29e5d9eb8677: ClarityError(StaticCheck(StaticCheckError { err: SupertypeTooLarge, expressions: Some([SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"append\")), id: 41 }, SymbolicExpression { expr: Atom(ClarityName(\"initial\")), id: 42 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"tuple\")), id: 44 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"a\")), id: 46 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 48 }, SymbolicExpression { expr: Atom(ClarityName(\"small\")), id: 49 }]), id: 47 }]), id: 45 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"b\")), id: 51 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 53 }, SymbolicExpression { expr: Atom(ClarityName(\"big\")), id: 54 }]), id: 52 }]), id: 50 }]), id: 43 }]), id: 40 }]), diagnostic: Diagnostic { level: Error, message: \"supertype of two types is too large\", spans: [Span { start_line: 0, start_column: 0, end_line: 0, end_column: 0 }], suggestion: None } }))"), + Failure("Invalid Stacks block 95378f7e883c3fe5ed43a4985538ad5bd32c90066e67fa6e8bdc585a3d70eabd: ClarityError(StaticCheck(StaticCheckError { err: SupertypeTooLarge, expressions: Some([SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"append\")), id: 41 }, SymbolicExpression { expr: Atom(ClarityName(\"initial\")), id: 42 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"tuple\")), id: 44 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"a\")), id: 46 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 48 }, SymbolicExpression { expr: Atom(ClarityName(\"small\")), id: 49 }]), id: 47 }]), id: 45 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"b\")), id: 51 }, SymbolicExpression { expr: List([SymbolicExpression { expr: Atom(ClarityName(\"var-get\")), id: 53 }, SymbolicExpression { expr: Atom(ClarityName(\"big\")), id: 54 }]), id: 52 }]), id: 50 }]), id: 43 }]), id: 40 }]), diagnostic: Diagnostic { level: Error, message: \"supertype of two types is too large\", spans: [Span { start_line: 0, start_column: 0, end_line: 0, end_column: 0 }], suggestion: None } }))"), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_type_error.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_type_error.snap new file mode 100644 index 00000000000..52873cce993 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_type_error.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "74d6f785e1fd566218d9ab6bce0b192be81a00a212388ab4cb8ade9e9f7c2187", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-error-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'int\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fc9d45a0e8ba69da00d8335219cbbcd6045d6b6acb07d4398f1afd5364416a46", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-error-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'int\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1277, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1277, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7562937bc5dc0e281095ec8355f65f74dc8f2769aae81c62d302c9b110ccf035", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-error-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'int\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1277, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1277, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "676a44d106682b11ad6b78597d3465910d6259239ef187b34f1f0c0310c08f48", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-error-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'int\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2d29139d01a522f8c1de01afd923a8626fbec84f2438867b808e845ac5077297", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-error-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'int\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1277, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1277, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2c26b3ba5f6bb382bafe89bb106418c5b8975050efaae5fb63dad167b89f5cfa", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-error-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'int\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1277, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1277, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "62cdd39b8e372eb0871d9d519b706a62607f1104d1a4d639a38b47a718d94db9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-error-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting expression of type \'int\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1277, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1277, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_type_signature_too_deep.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_type_signature_too_deep.snap new file mode 100644 index 00000000000..7feaf5c47fe --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_type_signature_too_deep.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "92722fd0e06347752525f30dbcb2548610a544fe718cf2f22b510ed902fb67d8", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: signature-too-deep-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: created a type which was deeper than maximum allowed type depth) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d6752a5a015135f531306324e2e292fb00dc812b4a1fe2aa1d5f08e95fab9b2f", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: signature-too-deep-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: created a type which was deeper than maximum allowed type depth) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9a3097e660297390b928d6b5ac6a4972fde3f9facd35b7bd05a42e0d51288a99", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: signature-too-deep-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: created a type which was deeper than maximum allowed type depth) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5141ca8eaafdde32bb181354335bc23234adbd9f04d82b029bff60fdc0b8d0cd", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: signature-too-deep-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: created a type which was deeper than maximum allowed type depth) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "47330f59fd1e4d3278b3f21b6c8fea0c87bc9ea84c701eab98eace0c95475ff9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: signature-too-deep-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: created a type which was deeper than maximum allowed type depth) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1aaf590ced3ebff3a77fb698e3f03454ba27d2c079e8fc2738ceb5bf35f35823", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: signature-too-deep-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: created a type which was deeper than maximum allowed type depth) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "afc0e48eb38abc630e447124fc64ab89a433b3468ace59b58aa6c06aa2418d5e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: signature-too-deep-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: created a type which was deeper than maximum allowed type depth) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 77, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 12036, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_undefined_variable.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_undefined_variable.snap new file mode 100644 index 00000000000..8195f5cb9cd --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_undefined_variable.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "c043bd4d6a38f46727e3be3aa60d256258fd1f1fc72baffd8380c50c9ad37a2b", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undefined-variable-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved variable \'x\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bacb4f57361bcf60b8ff2e747e5b00f28e7c495e1f2edfef72bfe4d8b016fe5b", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undefined-variable-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved variable \'x\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "22decf46c04d5bc7f6c56b66de09c9960d4ccc1f5956f78e354af08c64efaafe", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undefined-variable-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved variable \'x\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f804f6f86fa341b65c0bbd37ff529574928623f1fe7b1e0530bfc85cd557488c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undefined-variable-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved variable \'x\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "aec1a848cbd01d476fd7d9cf2989af24a81bb4bf363e8ed4101d67d7f0cf1fc0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undefined-variable-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved variable \'x\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9e9ac302c6b5018919a62e00324586ff205add6cf520e7f0a0349f0ed1969242", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undefined-variable-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved variable \'x\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8c9994b2984b0fc1a9e762e633aa01c1c09f5cb1a2e1cf6786a726999cfba7bc", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undefined-variable-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: use of unresolved variable \'x\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 517, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unknown_type_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unknown_type_name.snap new file mode 100644 index 00000000000..57a7e2450f1 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unknown_type_name.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "d948f6860d4010cca945ee430a70d16dca46d5eed0ca23b094ac99785fc5b352", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-type-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'from-consensus-buff?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2394, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2394, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "542841ab75c0653eb5804a833c07cc6fa638f3773f2a91ee15c77366c0c71eed", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-type-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: failed to parse type: \'foo\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2519, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2519, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7fd845e89c7bf47f659bde8e677dc424cb306f50072d110c0cacf1fb33576fc0", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-type-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: failed to parse type: \'foo\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2519, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2519, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "250f89bee59448c6bde2ab9ef1b691453d6cfa44d907bd757ff0f4f67b2ad690", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-type-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'from-consensus-buff?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2394, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2394, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6d8534be2a3ffc6931ade049040c1375bbf7f0b89c34b0beda21e574e95ad3cb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-type-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: failed to parse type: \'foo\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2519, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2519, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9b844f6346eddefdefecd948131a8c834760c4da7b18f0dc1c93b493f539616a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-type-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: failed to parse type: \'foo\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2519, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2519, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b4b773adb2ab7c0a911bc91e5033a955693547e11a1a084578065badf8c6bdc0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-type-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: failed to parse type: \'foo\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2519, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2519, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_value_out_of_bounds.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_value_out_of_bounds.snap new file mode 100644 index 00000000000..6390dddd545 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_value_out_of_bounds.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "bac3f91272f70bddd13b04c59ae408ef7c070bc6348f41e60bb7730dae8d8ea5", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-out-of-bounds-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: created a type which value size was out of defined bounds) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f034160993978c7a7a0d416282cb10e2e0b13ee40e30f5e5957e2b12128641c2", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-out-of-bounds-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: created a type which value size was out of defined bounds) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "60cdc22e59cf8b5e5e62fcaaf48a97d63bbdf8fd3ce278d27ccaba9417cd9c41", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-out-of-bounds-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: created a type which value size was out of defined bounds) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "38c265047b55cb58c55397c47b0b1e5142bd36e0514a78f31413d870193c31e9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-out-of-bounds-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: created a type which value size was out of defined bounds) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "443f1ba154dc7bbd812cd0c11d6321a189ba27fa158d21f68fd75df800f89294", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-out-of-bounds-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: created a type which value size was out of defined bounds) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "afa9e908232f2e5daab50e10187c489614a4a5ae50d503c94cd9304564427975", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-out-of-bounds-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: created a type which value size was out of defined bounds) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9b9d30419f4277b33962e087de2866e8ed04b092322708ded8ecf898544e4344", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-out-of-bounds-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: created a type which value size was out of defined bounds) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 16, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2200, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_value_too_large.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_value_too_large.snap new file mode 100644 index 00000000000..71e1edc813e --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_value_too_large.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "65b4b5273232a1675abbcfc3ef10bc3d906b3841c23374a45e71ccc53e150278", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: created a type which was greater than maximum allowed value size) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7526aede109c52b2d53c7dab7bfa45cb97f1fbc0fe4f2050343d9dae34b02836", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: created a type which was greater than maximum allowed value size) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a8bb8bff10ea5c92bed4ae04ebba6f4d686b6ba4ce7d8b3ff717302d172f7475", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: created a type which was greater than maximum allowed value size) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ad71396daa08843eef1466565920daa29b10c33d1e4eea790d3aa9e6accd88bd", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: created a type which was greater than maximum allowed value size) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "59a40862be6dd98d574fd33038657f7573a7a91d1162c9b171b82139f4389fff", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: created a type which was greater than maximum allowed value size) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "da28ebf6e6b77e76482bbd03b119b6fbb37232da246caf687cb2ab87468b64f8", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: created a type which was greater than maximum allowed value size) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1b2bc788c819675438943411ce9614cdbd2d1f2309643448d9d0a195053adfd2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: created a type which was greater than maximum allowed value size) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1024, + ), + )), +] From b6f048c3664f9c80cd4ee0982f34e6d44921520b Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Thu, 6 Nov 2025 15:10:59 +0000 Subject: [PATCH 05/40] removed unused CommonCheckErrorKind::CouldNotDetermineSerializationType --- clarity-types/src/errors/analysis.rs | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index a5d2a11362c..35925f02d39 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -219,9 +219,6 @@ pub enum CommonCheckErrorKind { /// The `String` wraps the non-existent type name. UnknownTypeName(String), - /// Could not determine the serialization type for a value during analysis. - CouldNotDetermineSerializationType, - /// Could not determine the type of an expression during analysis. CouldNotDetermineType, @@ -651,8 +648,6 @@ pub enum CheckErrorKind { /// Expected an optional or response value but found a different value. /// The `Box` wraps the actual value provided. ExpectedOptionalOrResponseValue(Box), - /// Could not determine the serialization type for a value during analysis. - CouldNotDetermineSerializationType, /// Expected a contract principal value but found a different value. /// The `Box` wraps the actual value provided. ExpectedContractPrincipalValue(Box), @@ -1117,9 +1112,6 @@ impl From for CheckErrorKind { CommonCheckErrorKind::TypeError(a, b) => CheckErrorKind::TypeError(a, b), CommonCheckErrorKind::BadSyntaxBinding(e) => CheckErrorKind::BadSyntaxBinding(e), CommonCheckErrorKind::ValueOutOfBounds => CheckErrorKind::ValueOutOfBounds, - CommonCheckErrorKind::CouldNotDetermineSerializationType => { - CheckErrorKind::CouldNotDetermineSerializationType - } CommonCheckErrorKind::EmptyTuplesNotAllowed => CheckErrorKind::EmptyTuplesNotAllowed, CommonCheckErrorKind::NameAlreadyUsed(name) => CheckErrorKind::NameAlreadyUsed(name), CommonCheckErrorKind::UnknownTypeName(name) => CheckErrorKind::UnknownTypeName(name), @@ -1180,9 +1172,6 @@ impl From for StaticCheckErrorKind { CommonCheckErrorKind::TypeError(a, b) => StaticCheckErrorKind::TypeError(a, b), CommonCheckErrorKind::BadSyntaxBinding(e) => StaticCheckErrorKind::BadSyntaxBinding(e), CommonCheckErrorKind::ValueOutOfBounds => StaticCheckErrorKind::ValueOutOfBounds, - CommonCheckErrorKind::CouldNotDetermineSerializationType => { - StaticCheckErrorKind::CouldNotDetermineSerializationType - } CommonCheckErrorKind::EmptyTuplesNotAllowed => { StaticCheckErrorKind::EmptyTuplesNotAllowed } @@ -1468,7 +1457,6 @@ impl DiagnosableError for CheckErrorKind { CheckErrorKind::InvalidCharactersDetected => "invalid characters detected".into(), CheckErrorKind::InvalidUTF8Encoding => "invalid UTF8 encoding".into(), CheckErrorKind::InvalidSecp65k1Signature => "invalid seckp256k1 signature".into(), - CheckErrorKind::CouldNotDetermineSerializationType => "could not determine the input type for the serialization function".into(), CheckErrorKind::ExpectedListOfAllowances(fn_name, arg_num) => format!("{fn_name} expects a list of asset allowances as argument {arg_num}"), CheckErrorKind::AllowanceExprNotAllowed => "allowance expressions are only allowed in the context of a `restrict-assets?` or `as-contract?`".into(), CheckErrorKind::ExpectedAllowanceExpr(got_name) => format!("expected an allowance expression, got: {got_name}"), From 34bfcf89b9b049002ba6b073260a9d31a45dfaa6 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Thu, 6 Nov 2025 18:10:50 +0000 Subject: [PATCH 06/40] add second set of StaticCheckError consensus tests --- stackslib/src/chainstate/tests/consensus.rs | 353 ++++++++++++++++-- ...static_check_error_bad_syntax_binding.snap | 216 +++++++++++ ...us__static_check_error_bad_token_name.snap | 216 +++++++++++ ...check_error_contract_call_expect_name.snap | 216 +++++++++++ ...ould_not_determine_serialization_type.snap | 216 +++++++++++ ..._check_error_could_not_determine_type.snap | 216 +++++++++++ ..._check_error_default_types_must_match.snap | 216 +++++++++++ ..._check_error_define_nft_bad_signature.snap | 216 +++++++++++ ...heck_error_define_trait_bad_signature.snap | 216 +++++++++++ ...k_error_define_trait_duplicate_method.snap | 212 +++++++++++ ..._check_error_empty_tuples_not_allowed.snap | 216 +++++++++++ ...or_expected_optional_or_response_type.snap | 216 +++++++++++ ..._static_check_error_expected_sequence.snap | 216 +++++++++++ ...static_check_error_if_arms_must_match.snap | 216 +++++++++++ ...legal_or_unknown_function_application.snap | 216 +++++++++++ ...static_check_error_incompatible_trait.snap | 216 +++++++++++ ..._check_error_incorrect_argument_count.snap | 216 +++++++++++ ...eck_error_no_such_block_info_property.snap | 216 +++++++++++ ...__static_check_error_no_such_contract.snap | 216 +++++++++++ ...tic_check_error_no_such_data_variable.snap | 216 +++++++++++ ...sensus__static_check_error_no_such_ft.snap | 216 +++++++++++ ...ensus__static_check_error_no_such_nft.snap | 216 +++++++++++ ..._check_error_non_function_application.snap | 216 +++++++++++ ...heck_error_requires_at_most_arguments.snap | 216 +++++++++++ ...sus__static_check_error_reserved_word.snap | 216 +++++++++++ ...rror_unchecked_intermediary_responses.snap | 216 +++++++++++ ...r_unexpected_trait_or_field_reference.snap | 216 +++++++++++ ...__static_check_error_union_type_error.snap | 216 +++++++++++ ...__static_check_error_unknown_function.snap | 216 +++++++++++ 29 files changed, 6368 insertions(+), 29 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_syntax_binding.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_token_name.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_contract_call_expect_name.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_serialization_type.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_type.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_default_types_must_match.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_nft_bad_signature.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_trait_bad_signature.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_trait_duplicate_method.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_empty_tuples_not_allowed.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_optional_or_response_type.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_sequence.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_if_arms_must_match.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_illegal_or_unknown_function_application.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_incompatible_trait.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_incorrect_argument_count.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_block_info_property.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_contract.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_data_variable.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_ft.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_nft.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_non_function_application.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_requires_at_most_arguments.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_reserved_word.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unchecked_intermediary_responses.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unexpected_trait_or_field_reference.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_union_type_error.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unknown_function.snap diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index 880176b0512..feb3666d491 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -1270,6 +1270,15 @@ contract_deploy_consensus_test!( contract_code: "(match)", ); +// StaticCheckError: [`StaticCheckErrorKind::RequiresAtMostArguments`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_requires_at_most_arguments, + contract_name: "requires-at-most", + contract_code: r#"(principal-construct? 0x22 0xfa6bf38ed557fe417333710d6033e9419391a320 "foo" "bar")"#, +); + // StaticCheckError: [`StaticCheckErrorKind::BadMatchInput`] // Caused by: // Outcome: block accepted. @@ -1405,6 +1414,15 @@ contract_deploy_consensus_test!( (ok (from-consensus-buff? foo 0x00)))", ); +// StaticCheckError: [`StaticCheckErrorKind::UnionTypeError`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_union_type_error, + contract_name: "union-type-error", + contract_code: "(map - (list true false true false))", +); + // StaticCheckError: [`StaticCheckErrorKind::UndefinedVariable`] // Caused by: // Outcome: block accepted. @@ -1423,6 +1441,283 @@ contract_deploy_consensus_test!( contract_code: "(define-map lists { name: int } contents)", ); +// StaticCheckError: [`StaticCheckErrorKind::CouldNotDetermineType`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_could_not_determine_type, + contract_name: "could-not-determine", + contract_code: "(index-of (list) none)", +); + +// StaticCheckError: [`StaticCheckErrorKind::ExpectedSequence`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_expected_sequence, + contract_name: "expected-sequence", + contract_code: r#"(index-of 3 "a")"#, +); + +// StaticCheckError: [`StaticCheckErrorKind::CouldNotDetermineSerializationType`] +// Caused by: +// Outcome: block accepted. +// Note: during analysis, this error can only be triggered by `from-consensus-buff?` +// which is only available in Clarity 2 and later. So Clarity 1 will not trigger +// this error. +contract_deploy_consensus_test!( + static_check_error_could_not_determine_serialization_type, + contract_name: "serialization-type", + contract_code: " + (define-trait trait-a ((ping () (response bool bool)))) + (define-trait trait-b ((pong () (response bool bool)))) + (define-public (trigger (first ) (second )) + (ok (to-consensus-buff? (list first second))))", +); + +// StaticCheckError: [`StaticCheckErrorKind::UncheckedIntermediaryResponses`] +// Caused by: Intermediate `(ok ...)` expressions inside a `begin` block that are not unwrapped. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_unchecked_intermediary_responses, + contract_name: "unchecked-resp", + contract_code: " + (define-public (trigger) + (begin + (ok true) + (ok true)))", +); + +// StaticCheckError: [`StaticCheckErrorKind::NoSuchFT`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_no_such_ft, + contract_name: "no-such-ft", + contract_code: "(ft-get-balance stackoos tx-sender)", +); + +// StaticCheckError: [`StaticCheckErrorKind::NoSuchNFT`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_no_such_nft, + contract_name: "no-such-nft", + contract_code: r#"(nft-get-owner? stackoos "abc")"#, +); + +// StaticCheckError: [`StaticCheckErrorKind::DefineNFTBadSignature`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_define_nft_bad_signature, + contract_name: "nft-bad-signature", + contract_code: "(define-non-fungible-token stackaroos integer)", +); + +// StaticCheckError: [`StaticCheckErrorKind::BadTokenName`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_bad_token_name, + contract_name: "bad-token-name", + contract_code: "(ft-get-balance u1234 tx-sender)", +); + +// StaticCheckError: [`StaticCheckErrorKind::EmptyTuplesNotAllowed`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_empty_tuples_not_allowed, + contract_name: "empty-tuples-not", + contract_code: " + (define-private (set-cursor (value (tuple))) + value)", +); + +// StaticCheckError: [`StaticCheckErrorKind::NoSuchDataVariable`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_no_such_data_variable, + contract_name: "no-such-data-var", + contract_code: " + (define-private (get-cursor) + (unwrap! (var-get cursor) 0))", +); + +// StaticCheckError: [`StaticCheckErrorKind::NonFunctionApplication`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_non_function_application, + contract_name: "non-function-appl", + contract_code: "((lambda (x y) 1) 2 1)", +); + +// StaticCheckError: [`StaticCheckErrorKind::NoSuchContract`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_no_such_contract, + contract_name: "no-such-contract", + contract_code: "(contract-call? 'S1G2081040G2081040G2081040G208105NK8PE5.contract-name test! u1)", +); + +// StaticCheckError: [`StaticCheckErrorKind::ContractCallExpectName`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_contract_call_expect_name, + contract_name: "ccall-expect-name", + contract_code: "(contract-call? 'S1G2081040G2081040G2081040G208105NK8PE5.contract-name u1)", +); + +// StaticCheckError: [`StaticCheckErrorKind::DefaultTypesMustMatch`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_default_types_must_match, + contract_name: "default-types-must", + contract_code: " + (define-map tokens { id: int } { balance: int }) + (default-to false (get balance (map-get? tokens (tuple (id 0)))))", +); + +// StaticCheckError: [`StaticCheckErrorKind::IfArmsMustMatch`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_if_arms_must_match, + contract_name: "if-arms-must-match", + contract_code: "(if true true 1)", +); + +// StaticCheckError: [`StaticCheckErrorKind::IllegalOrUnknownFunctionApplication`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_illegal_or_unknown_function_application, + contract_name: "illegal-or-unknown", + contract_code: "(map if (list 1 2 3 4 5))", +); + +// StaticCheckError: [`StaticCheckErrorKind::UnknownFunction`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_unknown_function, + contract_name: "unknown-function", + contract_code: "(ynot 1 2)", +); + +// // StaticCheckError: [`StaticCheckErrorKind::UTraitReferenceUnknownnknownFunction`] +// // Caused by: +// // Outcome: block accepted. +// contract_deploy_consensus_test!( +// static_check_error_trait_reference_unknown, +// contract_name: "trait-ref-unknown", +// contract_code: "", +// ); + +// StaticCheckError: [`StaticCheckErrorKind::IncorrectArgumentCount`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_incorrect_argument_count, + contract_name: "incorrect-arg-count", + contract_code: "(len (list 1) (list 1))", +); + +// StaticCheckError: [`StaticCheckErrorKind::BadSyntaxBinding`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_bad_syntax_binding, + contract_name: "bad-syntax-binding", + contract_code: "(let ((1)) (+ 1 2))", +); + +// StaticCheckError: [`StaticCheckErrorKind::ExpectedOptionalOrResponseType`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_expected_optional_or_response_type, + contract_name: "exp-opt-or-res", + contract_code: "(try! 3)", +); + +// StaticCheckError: [`StaticCheckErrorKind::DefineTraitBadSignature`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_define_trait_bad_signature, + contract_name: "def-trait-bad-sign", + contract_code: "(define-trait trait-1 ((get-1 uint uint)))", +); + +// StaticCheckError: [`StaticCheckErrorKind::DefineTraitDuplicateMethod`] +// Caused by: +// Outcome: block accepted. +// Note: This error was added in Clarity 2. Clarity 1 will accept the contract. +contract_deploy_consensus_test!( + static_check_error_define_trait_duplicate_method, + contract_name: "def-trait-dup-method", + contract_code: " + (define-trait double-method ( + (foo (uint) (response uint uint)) + (foo (bool) (response bool bool)) + ))", +); + +// StaticCheckError: [`StaticCheckErrorKind::UnexpectedTraitOrFieldReference`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_unexpected_trait_or_field_reference, + contract_name: "trait-or-field-ref", + contract_code: "(+ 1 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR.contract.field)", +); + +// StaticCheckError: [`StaticCheckErrorKind::IncompatibleTrait`] +// Caused by: pass a trait to a trait parameter which is not compatible. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_incompatible_trait, + contract_name: "incompatible-trait", + contract_code: " + (define-trait trait-1 ( + (get-1 (uint) (response uint uint)) + )) + (define-trait trait-2 ( + (get-2 (uint) (response uint uint)) + )) + (define-public (wrapped-get-2 (contract )) + (internal-get-2 contract)) + (define-public (internal-get-2 (contract )) + (contract-call? contract get-2 u1))", +); + +// StaticCheckError: [`StaticCheckErrorKind::ReservedWord`] +// Caused by: +// Outcome: block accepted. +// Note: This error was added in Clarity 3. Clarity 1 and 2 +// will trigger a [`StaticCheckErrorKind::NameAlreadyUsed`]. +contract_deploy_consensus_test!( + static_check_error_reserved_word, + contract_name: "reserved-word", + contract_code: "(define-private (block-height) true)", +); + +// StaticCheckError: [`StaticCheckErrorKind::NoSuchBlockInfoProperty`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_no_such_block_info_property, + contract_name: "no-such-block-info", + contract_code: "(get-burn-block-info? none u1)", +); + // pub enum StaticCheckErrorKind { // CostOverflow, // CostBalanceExceeded(ExecutionCost, ExecutionCost), @@ -1442,28 +1737,28 @@ contract_deploy_consensus_test!( // TypeError(Box, Box), [`static_check_error_type_error`] // InvalidTypeDescription, [`static_check_error_invalid_type_description`] // UnknownTypeName(String), [`static_check_error_unknown_type_name`] -// UnionTypeError(Vec, Box), +// UnionTypeError(Vec, Box), [`static_check_error_union_type_error`] // ExpectedOptionalType(Box), [`static_check_error_expected_optional_type`] // ExpectedResponseType(Box), [`static_check_error_expected_response_type`] -// ExpectedOptionalOrResponseType(Box), +// ExpectedOptionalOrResponseType(Box), [`static_check_error_expected_optional_or_response_type`] // CouldNotDetermineResponseOkType, [`static_check_error_could_not_determine_response_ok_type`] // CouldNotDetermineResponseErrType, [`static_check_error_could_not_determine_response_err_type`] -// CouldNotDetermineSerializationType, -// UncheckedIntermediaryResponses, +// CouldNotDetermineSerializationType, [`static_check_error_could_not_determine_serialization_type`] +// UncheckedIntermediaryResponses, [`static_check_error_unchecked_intermediary_responses`] // CouldNotDetermineMatchTypes, [`static_check_error_could_not_determine_match_types`] -// CouldNotDetermineType, +// CouldNotDetermineType, [`static_check_error_could_not_determine_type`] // TypeAlreadyAnnotatedFailure, // CheckerImplementationFailure, -// BadTokenName, -// DefineNFTBadSignature, -// NoSuchNFT(String), -// NoSuchFT(String), +// BadTokenName, [`static_check_error_bad_token_name`] +// DefineNFTBadSignature, [`static_check_error_define_nft_bad_signature`] +// NoSuchNFT(String), [`static_check_error_no_such_nft`] +// NoSuchFT(String), [`static_check_error_no_such_ft`] // BadTupleFieldName, // ExpectedTuple(Box), // NoSuchTupleField(String, TupleTypeSignature), -// EmptyTuplesNotAllowed, +// EmptyTuplesNotAllowed, [`static_check_error_empty_tuples_not_allowed`] // BadTupleConstruction(String), -// NoSuchDataVariable(String), +// NoSuchDataVariable(String), [`static_check_error_no_such_data_variable`] // BadMapName, // NoSuchMap(String), // DefineFunctionBadSignature, @@ -1471,13 +1766,13 @@ contract_deploy_consensus_test!( // BadMapTypeDefinition, [`static_check_error_bad_map_type_definition`] // PublicFunctionMustReturnResponse(Box), // DefineVariableBadSignature, [`static_check_error_define_variable_bad_signature`] -// ReturnTypesMustMatch(Box, Box), -// NoSuchContract(String), +// ReturnTypesMustMatch(Box, Box), [`static_check_error_return_types_must_match`] +// NoSuchContract(String), [`static_check_error_no_such_contract`] // NoSuchPublicFunction(String, String), // ContractAlreadyExists(String), -// ContractCallExpectName, +// ContractCallExpectName, [`static_check_error_contract_call_expect_name`] // ExpectedCallableType(Box), -// NoSuchBlockInfoProperty(String), +// NoSuchBlockInfoProperty(String), [`static_check_error_no_such_block_info_property`] // NoSuchStacksBlockInfoProperty(String), // NoSuchTenureInfoProperty(String), // GetBlockInfoExpectPropertyName, @@ -1486,32 +1781,32 @@ contract_deploy_consensus_test!( // GetTenureInfoExpectPropertyName, // NameAlreadyUsed(String), [`static_check_error_name_already_used`] // ReservedWord(String), -// NonFunctionApplication, +// NonFunctionApplication, [`static_check_error_non_function_application`] // ExpectedListApplication, -// ExpectedSequence(Box), +// ExpectedSequence(Box), [`static_check_error_expected_sequence`] // MaxLengthOverflow, // BadLetSyntax, -// BadSyntaxBinding(SyntaxBindingError), +// BadSyntaxBinding(SyntaxBindingError), [`static_check_error_bad_syntax_binding`] // MaxContextDepthReached, -// UndefinedVariable(String), +// UndefinedVariable(String), [`static_check_error_undefined_variable`] // RequiresAtLeastArguments(usize, usize), [`static_check_error_requires_at_least_arguments`] -// RequiresAtMostArguments(usize, usize), -// IncorrectArgumentCount(usize, usize), -// IfArmsMustMatch(Box, Box), +// RequiresAtMostArguments(usize, usize), [`static_check_error_requires_at_most_arguments`] +// IncorrectArgumentCount(usize, usize), [`static_check_error_incorrect_argument_count`] +// IfArmsMustMatch(Box, Box), [`static_check_error_if_arms_must_match`] // MatchArmsMustMatch(Box, Box), [`static_check_error_match_arms_must_match`] -// DefaultTypesMustMatch(Box, Box), -// IllegalOrUnknownFunctionApplication(String), -// UnknownFunction(String), +// DefaultTypesMustMatch(Box, Box), [`static_check_error_default_types_must_match`] +// IllegalOrUnknownFunctionApplication(String), [`static_check_error_illegal_or_unknown_function_application`] +// UnknownFunction(String), [`static_check_error_unknown_function`] // NoSuchTrait(String, String), // TraitReferenceUnknown(String), // TraitMethodUnknown(String, String), // ExpectedTraitIdentifier, // BadTraitImplementation(String, String), -// DefineTraitBadSignature, -// DefineTraitDuplicateMethod(String), -// UnexpectedTraitOrFieldReference, +// DefineTraitBadSignature, [`static_check_error_define_trait_bad_signature`] +// DefineTraitDuplicateMethod(String), [`static_check_error_define_trait_duplicate_method`] +// UnexpectedTraitOrFieldReference, [`static_check_error_unexpected_trait_or_field_reference`] // ContractOfExpectsTrait, -// IncompatibleTrait(Box, Box), +// IncompatibleTrait(Box, Box), [`static_check_error_incompatible_trait`] // WriteAttemptedInReadOnly, // AtBlockClosureMustBeReadOnly, // ExpectedListOfAllowances(String, i32), diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_syntax_binding.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_syntax_binding.snap new file mode 100644 index 00000000000..4e232e48e9a --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_syntax_binding.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "d696f9e3001bc26426552d727c8df876f826c6ee62de3bdd271a588ea636c30c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-syntax-binding-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid syntax binding: Let-binding item #1 is not a two-element list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "20d31008042fb4237ee60f0afcb1892b2855456a30e205f153cce00de4588056", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-syntax-binding-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid syntax binding: Let-binding item #1 is not a two-element list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7bab51c27df041c017b682a20bf39de7935d3f44e782880ce410371ddb069ca0", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-syntax-binding-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid syntax binding: Let-binding item #1 is not a two-element list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a29950883efd26632fc559edc9d5c4439e93eda57fd58fa449df06b42e4d8fb8", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-syntax-binding-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid syntax binding: Let-binding item #1 is not a two-element list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b9242c2b177956004572b8ac7e268e4111640e4cbd35e165fccfdc5ffb362e69", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-syntax-binding-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid syntax binding: Let-binding item #1 is not a two-element list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0971ee4efaf2749610aa2db4cb4749ae5e895568f7cd21e683265eebaf9ab57a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-syntax-binding-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid syntax binding: Let-binding item #1 is not a two-element list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fdc7b19c33638bacb9c7be1a6fdc9906da955be15d3e35efb0304096ddc16ed4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-syntax-binding-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: invalid syntax binding: Let-binding item #1 is not a two-element list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 666, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_token_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_token_name.snap new file mode 100644 index 00000000000..61e640721d8 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_token_name.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "d5b59f773e6001ae66d3f157abc1a9dc17dbd4c8648c1aa4eb83fb8840104c7c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-token-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting an token name as an argument) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1f66d1e0e5e3e06b9623e9684ca8de4ff7eb8e07c2eab7184ac972b5704bf3a3", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-token-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting an token name as an argument) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9ec2dfb5c1f2e47b36c544878c62666c0d7e70226a328a68003ab797a7285b98", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-token-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting an token name as an argument) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "68ad115eb6b3659e65ac35860e0160c1630c5accc500eb4c9e489697bc32e35d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-token-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting an token name as an argument) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "09981b2c1dc3caae1ff13f995a2dddfefb7ffeb5ff7436719a19d3916b6b587a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-token-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting an token name as an argument) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f2c630f11ed46ba229fd871c96c2b0c17488407a9700f16ba21e0b52bb8dbacb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-token-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting an token name as an argument) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5f9815679497baa906c79558a322ea6843f182e40aeb9794faa6efd1539f2776", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-token-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting an token name as an argument) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_contract_call_expect_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_contract_call_expect_name.snap new file mode 100644 index 00000000000..ec217f74c83 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_contract_call_expect_name.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "ef74c1a19d770af9ef3cc59d21a428f2bfb638a74c4179a928168138ff9f3b11", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: ccall-expect-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: missing contract name for call) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "381628ac6cf99f099508b942f755f3ad2ac1c2bbdba13e9b361a293699a24151", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: ccall-expect-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: missing contract name for call) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6e6d1155758a91ce1626beb6fa17817fd4d997edb6ec855df84b25c889575e7d", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: ccall-expect-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: missing contract name for call) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c08b2ffdcb91f6828a7dbe68ff82e0e45975430d776168cc4fcc8346819bad64", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: ccall-expect-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: missing contract name for call) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8ddf0b252eba6c6c03ced86903c566574d437e842dc175432ce4f4520cd17f9c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: ccall-expect-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: missing contract name for call) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fd5ad77a87ff67c0f969a5711a99fc99e72666e8df8cd6ddcf2aa7dee0873004", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: ccall-expect-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: missing contract name for call) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ea160b18b29d7eddd55b6b9483c7ac62edadafbff427ee532f14ff00b12594ea", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: ccall-expect-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: missing contract name for call) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2151, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_serialization_type.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_serialization_type.snap new file mode 100644 index 00000000000..16afa2066bc --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_serialization_type.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "e42a364d71fefb6651501389af27fe307a5de13c4e8dee3c86cc8ef3e5e34cbb", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: serialization-type-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'to-consensus-buff?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 7374, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 7374, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4f945895f61123311c1ab22d52a5d01c60e638370766cf0f9f1b1d457f68788e", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: serialization-type-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: could not determine the input type for the serialization function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 41, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7759, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 41, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7759, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8551543cd5309b05a5b348b8f535b0d753113af4a057780a92ecd891f63d93c5", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: serialization-type-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: could not determine the input type for the serialization function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 41, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7759, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 41, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7759, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "95def3c2080fc1544ae1c8a78baebafc204dff612da3203101b78d84e642103c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: serialization-type-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'to-consensus-buff?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 7374, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 7374, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "33d20fd2dec9f2ecdfb957d3108c9ac4c192d560a6deeb84a0a3770472a671e3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: serialization-type-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: could not determine the input type for the serialization function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 41, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7759, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 41, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7759, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f0954d1da1dc842483b2b91410221845cbccde66120ab93ca989cdc0854da7a1", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: serialization-type-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: could not determine the input type for the serialization function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 41, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7759, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 41, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7759, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0cc70e0c69e266c28a0c97522105962a9d235745b6f04c403895618ac84e72c3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: serialization-type-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: could not determine the input type for the serialization function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 41, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7759, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 41, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 7759, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_type.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_type.snap new file mode 100644 index 00000000000..14f332b042d --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_could_not_determine_type.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "bb62cdfab482aea78d323a917d9bc75e9efa14135ed4f4d8e527f50177ec1de6", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: type of expression cannot be determined) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1136, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1136, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "977706d8ae756e03f3c97fc1b1106bc1253fa9e01845d136045807efbdc040e7", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: type of expression cannot be determined) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1124, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1124, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1464a711d24eeb4eba3de78060d70753a9231b164662904065cbf209547d6884", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: type of expression cannot be determined) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1124, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1124, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "14bb2a965f9443a3680137a6dcda3fe3d02bcf2ea1e151d133dbf05a10477333", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: type of expression cannot be determined) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1136, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1136, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4c60fc22eeb154cade05ef726ec56fc4afd6d4ffcfbef343dbb3ead6783c36d5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: type of expression cannot be determined) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1124, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1124, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f43495a84b008a048236228a9856de756cddeab527368c84c877a1b6b92b2d0b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: type of expression cannot be determined) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1124, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1124, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "72796bba1e8fda1279e8e89e23b56b708d68ac56ef0e7ee1ae04f403e0c19960", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: could-not-determine-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: type of expression cannot be determined) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1124, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1124, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_default_types_must_match.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_default_types_must_match.snap new file mode 100644 index 00000000000..88bb3b34e8c --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_default_types_must_match.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "c0bd2968cf958ae46b24c81fd989f0165bc492df4da9d6fc7a56b59026e148e3", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: default-types-must-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expression types passed in \'default-to\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e712b94beac0f4491dcbaff5e74ce49327475643b02645cd73cce65da0680188", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: default-types-must-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expression types passed in \'default-to\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "68f5a9d95b112e6be0d0823610db5192d421273ec13c446b2d2d06f6599f37df", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: default-types-must-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expression types passed in \'default-to\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "27abb4db7cd1a35809c9bb60ad15d944b49b28c9ca91664473ac9d1273f48b15", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: default-types-must-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expression types passed in \'default-to\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f4c54d14eeeb8f35dca1eaa1e0a3421339b9f32e228cc72557504ab18e67083e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: default-types-must-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expression types passed in \'default-to\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e1265b3e5fd5ada33656b911882bdb4f7a89d3af59e4a6bad9d7e220f53e1bac", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: default-types-must-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expression types passed in \'default-to\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "72dd2b8fab3c0f26a0bf44d9847a7018a1d960d98328f150c4d105d241a84386", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: default-types-must-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expression types passed in \'default-to\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 28, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4991, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_nft_bad_signature.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_nft_bad_signature.snap new file mode 100644 index 00000000000..43d25ee788e --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_nft_bad_signature.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "9d578659db0d60582e0d0c2350b397495bc82815f341e1325694a87eefbc93e7", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: nft-bad-signature-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: (define-asset ...) expects an asset name and an asset identifier type signature as arguments) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "587ef0a9b094cd864dcd3771a81288162646d75884b9f2e59d4110f33622f34d", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: nft-bad-signature-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: (define-asset ...) expects an asset name and an asset identifier type signature as arguments) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d0abaed0c342bc60c9ce05d731ebd3c0a3ce6baed42cdd3cedfe5a73ff110099", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: nft-bad-signature-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: (define-asset ...) expects an asset name and an asset identifier type signature as arguments) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "17a3cec7ec58d352ff80c8104fa65e95fa57b46e88d579ae6949cae4d6d5b40b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: nft-bad-signature-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: (define-asset ...) expects an asset name and an asset identifier type signature as arguments) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3edaf8b1a00a4668254f00e0313212a8bc292f9df38671e253d15831709b92a7", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: nft-bad-signature-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: (define-asset ...) expects an asset name and an asset identifier type signature as arguments) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9c0996b34e0d4dae584888e1195b2cfbfbdbe63e8b24f03be8082dc626ed2503", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: nft-bad-signature-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: (define-asset ...) expects an asset name and an asset identifier type signature as arguments) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d1bab49a7843f53abb7289b0823ec497b6f61015a3c20cb99586aac93e79df90", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: nft-bad-signature-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: (define-asset ...) expects an asset name and an asset identifier type signature as arguments) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1497, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_trait_bad_signature.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_trait_bad_signature.snap new file mode 100644 index 00000000000..4f3e6834bd7 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_trait_bad_signature.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "3a48a506f1abc91b1217c52c7f31e123532b0cf06148ed8eefda0f14a1ce440b", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-bad-sign-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "13b7a1bb0bdd4e0794294b914b88eb5a2f842fba10bd8bca883e71bcd7feed37", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-bad-sign-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7cd581014d3018b01c0c0ddf883d3e5dabc31532f4f21243df1c6b25e2ce1127", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-bad-sign-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "afff2d61697520f7efd8f2ab133e63a82dd57edcbcbe093e17f0096b7dc48cef", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-bad-sign-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "65540d15ac9f264c1ee3bd863b92089a7a52f53935d8c9d7de9dbc22d25f15cc", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-bad-sign-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7bbccba48a34f23b650153fd06671bff8e6436ecaf2390d4f9c29b4b187009e5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-bad-sign-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c262440767091cd073fa28fdded3b9493b0843681df21cab04c1c3f44344cb30", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-bad-sign-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: invalid trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1397, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_trait_duplicate_method.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_trait_duplicate_method.snap new file mode 100644 index 00000000000..2622ab23f8b --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_trait_duplicate_method.snap @@ -0,0 +1,212 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "d87dce24182643eb929cf82a62da28e70d987832f89614fb054784115ac187ec", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-dup-method-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 163, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12905, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 163, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12905, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a4275f650a1ec5a86c3a4cd525808b3cabe33b84ae575211b4859ea8c3b23b68", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-dup-method-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: duplicate method name \'foo\' in trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4094, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4094, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "65d3ae524622816430f5acbcc36a409c1fb558cb4feac08e79c9bb07cd841ffd", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-dup-method-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: duplicate method name \'foo\' in trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4094, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4094, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fa1b6e29f1438950d1d2fe9b8beeb2db0d432ecb2c52f716295e2c9e62693579", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-dup-method-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 163, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12905, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 163, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12905, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "897f1bac786f2c7a40239c39231d9de6c3b1ff510e1fa8db8b482a12078826fc", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-dup-method-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: duplicate method name \'foo\' in trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4094, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4094, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9edda621a7d2e2d42cf0a44511fd995dfa12f0655760a0cc82fcc581fdcb775b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-dup-method-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: duplicate method name \'foo\' in trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4094, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4094, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ec6988334ad97bd35d6bd03a4230048e44e93dcef5a9b6509be1de3146862e0c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-trait-dup-method-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: duplicate method name \'foo\' in trait definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4094, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 4094, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_empty_tuples_not_allowed.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_empty_tuples_not_allowed.snap new file mode 100644 index 00000000000..deff863918d --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_empty_tuples_not_allowed.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "fe1fc0ccea753cb5d6832df1b96e543c0091e8a5841b5d0adae911b7287cc6dc", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: empty-tuples-not-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: tuple types may not be empty) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "df4e32328b2636c3a338ce2d95bdc379ce9d33e55cd2d0b7bfaa11768f858ed6", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: empty-tuples-not-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: tuple types may not be empty) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f512f4f6bb3d6dfa9211ce867e56e7cc5900405fc094652b12504f0f809e5fd1", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: empty-tuples-not-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: tuple types may not be empty) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "df7fe265493d65b06b3840d6d0d8389f141a4d1ee6ae8d734064999f27d46e77", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: empty-tuples-not-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: tuple types may not be empty) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4306e0961c90a5d877468300ff3fcd38f198d8ab41e31b28b52fc64203489a39", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: empty-tuples-not-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: tuple types may not be empty) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7073805e5313c96afc4b29fa9ae910fbd29f346748f985ea7eb4f50ed3a72080", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: empty-tuples-not-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: tuple types may not be empty) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6032e56b4fddbb4d620cdbba0eae89b181ff3e5e3e97730d7822f6ea5674b1b6", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: empty-tuples-not-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: tuple types may not be empty) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2209, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_optional_or_response_type.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_optional_or_response_type.snap new file mode 100644 index 00000000000..84cde0f6d91 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_optional_or_response_type.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "63e1266e59cea9eac8a0ad51610a9fead56c783447a7f0ec59c1d114f4946a0d", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-opt-or-res-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'optional\' or \'response\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a749e3d67cd17ffb7e147e554e35ccbe0440d4505fa30d4302b4956d10c62121", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-opt-or-res-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'optional\' or \'response\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ee6fcf1bbbac5e29c744614f39dde6248b82228f6c96b6332b73e8ddfb7155ce", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-opt-or-res-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'optional\' or \'response\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "938581bfd3ca4fb47e373e553a763d33278557daca9473a969b9fc688eeb1192", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-opt-or-res-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'optional\' or \'response\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "501c8741609cde446f77b793bf81bd4c6ec72418ad14c86c9a4382bff4c333a0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-opt-or-res-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'optional\' or \'response\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "614008cc3f4454b13e292475fb2d84102aa3bba7670ee09fcae13187842985d3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-opt-or-res-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'optional\' or \'response\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f7e39ffce92b2e5eb9f44c47e257a732e7c2b1dce9d3eaa0d4aa126cbbf975fc", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-opt-or-res-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting expression of type \'optional\' or \'response\', found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 485, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_sequence.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_sequence.snap new file mode 100644 index 00000000000..70250df25da --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_sequence.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5ba074a74da014e52ff1a01d1058774e6968b715ae3c20db1c2eaf82b5f098d6", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-sequence-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'list\', \'buff\', \'string-ascii\' or \'string-utf8\' - found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1cc5e0c8b3bc9f249d9f14afed0fa0edbfd222ce51f27dbdd95e926e7c1324d9", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-sequence-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'list\', \'buff\', \'string-ascii\' or \'string-utf8\' - found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b5e265970b875285922685a5008d2eda8701aa8b9ecf64ad9f71792ba3a52cbf", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-sequence-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'list\', \'buff\', \'string-ascii\' or \'string-utf8\' - found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "32b1d0caffd1aeb2b309a66b7aca6a82d3f900dc542e3f4e0ebc2c66384a11ab", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-sequence-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'list\', \'buff\', \'string-ascii\' or \'string-utf8\' - found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ca3253716542750ec91fbbd9bb91cfae7c9d6e81bb532798db3c7948c1915ab6", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-sequence-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'list\', \'buff\', \'string-ascii\' or \'string-utf8\' - found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "065e2332fe2378781bbb057debd3dea57276c3cebc87c95130d8a37cc9cd20eb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-sequence-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'list\', \'buff\', \'string-ascii\' or \'string-utf8\' - found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f7797846904f5abd2398e4467c3a3153a0fd5857963e3e90f503911c1f3d1fca", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-sequence-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting expression of type \'list\', \'buff\', \'string-ascii\' or \'string-utf8\' - found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 713, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_if_arms_must_match.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_if_arms_must_match.snap new file mode 100644 index 00000000000..fb45b373e47 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_if_arms_must_match.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5ba074a74da014e52ff1a01d1058774e6968b715ae3c20db1c2eaf82b5f098d6", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: if-arms-must-match-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expression types returned by the arms of \'if\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 981, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 981, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "56dc4f0e39abc83f2ddc1a8c50ce3845833bdc86452b9df347520baa54fd2ceb", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: if-arms-must-match-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expression types returned by the arms of \'if\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 980, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 980, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9d98ab25ef46c5fc5cacaf0c0851ac63fb36a1552746a1e07d58f157fee6bc31", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: if-arms-must-match-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expression types returned by the arms of \'if\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 980, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 980, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "611b5bea581961f9e3c0396d3e74402501d38f06a818404246c8bceee79b5a6a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: if-arms-must-match-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expression types returned by the arms of \'if\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 981, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 981, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "aefb34460ec0fd013a37cb0a273856e25ab7b3e85eaf2c2ac188f204ce296a4e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: if-arms-must-match-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expression types returned by the arms of \'if\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 980, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 980, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "658e6733f1cb7c7501ece5b6ca132eaa4f47df619fafd8c4a71640ac5faac587", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: if-arms-must-match-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expression types returned by the arms of \'if\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 980, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 980, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b74024a3ea874565b1960fcb28e340290764bfbf28b76a637b78e3719dc34628", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: if-arms-must-match-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expression types returned by the arms of \'if\' must match (got \'bool\' and \'int\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 980, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 980, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_illegal_or_unknown_function_application.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_illegal_or_unknown_function_application.snap new file mode 100644 index 00000000000..70f75427ed4 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_illegal_or_unknown_function_application.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5ad517322daee7a5aaca3c7cbbc0bcdefa9a3445e082cd183f627f5bc844e123", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: illegal-or-unknown-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of illegal / unresolved function \'if\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d431c6a483451b1e89d7411a00c66ffc23951234341ff603bba73ae5b1e5c12b", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: illegal-or-unknown-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of illegal / unresolved function \'if\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6d05ab5c78bf0edddb2d19bc87a5b38666aa7879f36afc1c78671caf660642bf", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: illegal-or-unknown-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of illegal / unresolved function \'if\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e73e473c56500c7c1b77073e71cb71cb45a0890d7be465ef20d1ad46a4594f7c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: illegal-or-unknown-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of illegal / unresolved function \'if\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8b312192e79777bd0c6536916efefd59fa3fd00d32058c71f85b0b543e47df5f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: illegal-or-unknown-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of illegal / unresolved function \'if\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8b0fb2859c3bc6464d2cb440ebcf8b91444b2533ee1c4c942f171e36f2940b17", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: illegal-or-unknown-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of illegal / unresolved function \'if\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7fa7d2a25ae640a2471c973cafc77190799bed16a3f473e971ba5c6117c022ee", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: illegal-or-unknown-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: use of illegal / unresolved function \'if\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 961, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_incompatible_trait.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_incompatible_trait.snap new file mode 100644 index 00000000000..ffce88bc0f8 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_incompatible_trait.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "e3b9dc5375970aa3cffb0cd449a35e0614b9d2e04969110aafeb31288e232eaf", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incompatible-trait-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'\', found \'\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10728, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10728, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "64084e08ee0034a17e75df04abb256b06261f1ee1d7509d1728c7a27396eff18", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incompatible-trait-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: trait \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.incompatible-trait-Epoch3_2-Clarity2.trait-1\' is not a compatible with expected trait, \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.incompatible-trait-Epoch3_2-Clarity2.trait-2\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10716, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10716, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8346b1db9804510e2a2987fdc96d5c6a3a03390aed5231fb89c5ddeb2d10ae20", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incompatible-trait-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: trait \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.incompatible-trait-Epoch3_2-Clarity3.trait-1\' is not a compatible with expected trait, \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.incompatible-trait-Epoch3_2-Clarity3.trait-2\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10716, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10716, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a19f367e92c1b568d36e1b80bd35eef4ae21e2a93beab4e16bb4072270410fdf", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incompatible-trait-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'\', found \'\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10728, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10728, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4d6c48fc9bfb49f96f4c38ec349720cb83648c1501473d1db85eeb254509628c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incompatible-trait-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: trait \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.incompatible-trait-Epoch3_3-Clarity2.trait-1\' is not a compatible with expected trait, \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.incompatible-trait-Epoch3_3-Clarity2.trait-2\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10716, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10716, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ad1a026a47dcfadb33c5752aa60c567f85f0adbcc1fe26cb98b1de4dc911f9a3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incompatible-trait-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: trait \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.incompatible-trait-Epoch3_3-Clarity3.trait-1\' is not a compatible with expected trait, \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.incompatible-trait-Epoch3_3-Clarity3.trait-2\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10716, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10716, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "07ba762806902d494ac6074b23a685f88ae87f67e6e629dfbd9ea1757caa5c9a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incompatible-trait-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: trait \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.incompatible-trait-Epoch3_3-Clarity4.trait-1\' is not a compatible with expected trait, \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.incompatible-trait-Epoch3_3-Clarity4.trait-2\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10716, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 47, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 10716, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_incorrect_argument_count.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_incorrect_argument_count.snap new file mode 100644 index 00000000000..0613cc2cd55 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_incorrect_argument_count.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "f66cce81e51343282596b8c2ce5e59e61090471ddb0901e3dbf5ccaa045429e3", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incorrect-arg-count-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting 1 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c40ce36d52627d291e7c58878e5d81ba64e7246cba0e856e9eb8125f65eb2af4", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incorrect-arg-count-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting 1 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b637e99ffab5314ad512a1ae41f1ed6fbb0926f1abdaf477aeff90e930c00b9d", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incorrect-arg-count-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting 1 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ace9d297fd8908543e3f66e70263e73785c2ce37638bbbab8bc989fd3d78f5c9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incorrect-arg-count-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting 1 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "11664be5c74b8f444886eb3ba0f15dc1ccea1e53e51cea38620894c9642cae42", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incorrect-arg-count-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting 1 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d28ef82aa96187a78176b36b0820624fbae639d2380a85a1db7c6997ebec12fa", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incorrect-arg-count-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting 1 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1b7f68a84ace5dba1497f80f8ea9ac96fb12852a081357107b08ec0c1614ee1d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: incorrect-arg-count-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting 1 arguments, got 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 885, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_block_info_property.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_block_info_property.snap new file mode 100644 index 00000000000..6ec11adae95 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_block_info_property.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "f4f61c95b8100ce2ccc709a481727b002fac137e607966ebd4b4024b5f60e552", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-block-info-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-burn-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "38477a2a6242b1f5ea78ebc600e3cdd46f6b7d4d0d4cf778bb05c117bcace656", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-block-info-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of block unknown property \'none\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "268a76cc165d32783b5b3a3d5e9330a2c2ca3fdb75b73406b8130d5c4f8c6eff", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-block-info-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of block unknown property \'none\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a219036ca293fa617179b88967a6429beb239201a2af88e532e67ce4b1be2ce2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-block-info-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-burn-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b378a0f67dbab90e40536006d0c189ffe300cdff248cd42daa26179381d621d6", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-block-info-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of block unknown property \'none\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b82f14e085d409dbc25e576f7463fe4b98482b4e7f95eff1483702c2cce61d03", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-block-info-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of block unknown property \'none\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7b5b8b73d3be7cbb165a1988e1d7ff3451b5904ebc745545e35dd6fdec94960d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-block-info-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: use of block unknown property \'none\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_contract.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_contract.snap new file mode 100644 index 00000000000..3b707bed957 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_contract.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "360c7491e58e5866e3ba7f8de6751964d17d13e28d2bf8a3f7496ab6b09d3766", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-contract-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved contract \'S1G2081040G2081040G2081040G208105NK8PE5.contract-name\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "260c26dc23e0c11a2602be0942d2854b21bfd40522fcdc192eb3904d41b75a00", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-contract-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved contract \'S1G2081040G2081040G2081040G208105NK8PE5.contract-name\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8dff4cf5dbcfba8f1ae61b4ebc1c3e7c7de5194c50f7cf25b47656e0d38f2906", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-contract-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved contract \'S1G2081040G2081040G2081040G208105NK8PE5.contract-name\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "94219bc0151a17199cc554a41148cb558d1a89df4e09a6c3d28910eab3839b85", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-contract-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved contract \'S1G2081040G2081040G2081040G208105NK8PE5.contract-name\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5a1c328307b361b885969b0773be32f602bedeed43dcf263500bf3856d061fb9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-contract-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved contract \'S1G2081040G2081040G2081040G208105NK8PE5.contract-name\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2b01065a7596aee98f22f69e365648edebdb449840f81c06b5533c6d05d7bb9c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-contract-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved contract \'S1G2081040G2081040G2081040G208105NK8PE5.contract-name\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bdf61f6d810cd859e26ce9b23867319213aec6f3ed0f04c398fe5a0a5d37f2e7", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-contract-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: use of unresolved contract \'S1G2081040G2081040G2081040G208105NK8PE5.contract-name\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2313, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_data_variable.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_data_variable.snap new file mode 100644 index 00000000000..e98c712132e --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_data_variable.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "bcccc5b765cdc772cc53f74e7cbfbe72f47d5e63de644373bf30c090c503074c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-data-var-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved persisted variable \'cursor\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "203f538593aa699761eca56ef17ea8bc518f7f82c793dfe67409554013e58d99", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-data-var-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved persisted variable \'cursor\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "be8dde9fcf636ffa1be1db0c44b000276926d1556eb9968f6e9a2601c7b37e7c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-data-var-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved persisted variable \'cursor\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "97f6cf194776a1a84815e93cd1bffbf6a488568ed55cf4d96d1e2c3d94532952", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-data-var-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved persisted variable \'cursor\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ddbe424e407b7fd121cb6dc65f5feb7cc09e9c9076908e547e50105e22b48a6a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-data-var-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved persisted variable \'cursor\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0f22acad15a59a4609244bf14a1f1eca2a801e0e078aa41bdb3843cafe48abc4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-data-var-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved persisted variable \'cursor\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3d010a184b1941b0e6bff12953bf767d174e607288058ba708881af47b5180ec", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-data-var-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: use of unresolved persisted variable \'cursor\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2402, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_ft.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_ft.snap new file mode 100644 index 00000000000..0f7e5b9c100 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_ft.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "43bd53a10611e249b013aee865a9d9d482d7e58b8c6f713fbeee24c9805507fd", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-ft-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: tried to use token function with a undefined token (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f613c806933585c6c0b49003bf50a4cb41c857eaf1fa1099e830f86c814a14bd", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-ft-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: tried to use token function with a undefined token (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "eaeb328a8230892d293f30ed01ccb50cb24b72a7d28266918fe41d1ff1226f44", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-ft-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: tried to use token function with a undefined token (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5eb5f5f59f9ba45fef21add6c082ea402287aae8dd5773079fa1b1de9e46174c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-ft-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: tried to use token function with a undefined token (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6160e2aea9134406d30229cfaa25bbb05789d38da6fb1ea55e1234e390903b0d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-ft-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: tried to use token function with a undefined token (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e5e4afd627d96d81de18fa7ce33b07e5504c785cf2cbd85256cdbd8d0548af5d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-ft-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: tried to use token function with a undefined token (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ec0722335ef5e36b8768cd2053d0f940f9337a4dfc757567192b61a449b03c3f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-ft-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: tried to use token function with a undefined token (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1201, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_nft.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_nft.snap new file mode 100644 index 00000000000..c75e3a11a4e --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_nft.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "3a0a1c6deb0acda3f8833093f8c4771b97e4691b3656f32c1a1effa8997a4b78", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-nft-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: tried to use asset function with a undefined asset (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "39fcc0baf43a1ded5e48215e81a9a8abf4794c034992bef8bcfcc0c20cba3252", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-nft-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: tried to use asset function with a undefined asset (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b18ad04bebf58ae4f2af22cfd2a9c1bbfc00928ed886df58d0ef8c198d9b4d12", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-nft-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: tried to use asset function with a undefined asset (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "623e212c300835f68aa03dfb7a09fd92a0067cf49559930d3dd82d4b4a820d15", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-nft-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: tried to use asset function with a undefined asset (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6d20fad3b028b0bddccacf81e2a7e138442c0a2f9fce27a8c3df368a0141fb6c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-nft-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: tried to use asset function with a undefined asset (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b353f50664d83bce6b45b1fbedaf2cd2c141b423f75803c7b79647fa3a51c804", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-nft-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: tried to use asset function with a undefined asset (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "925b943fb2fadb1819f0ecc50c0bca59d8e43261302f49888ad5e17236a2b746", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-nft-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: tried to use asset function with a undefined asset (\'stackoos\')) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1093, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_non_function_application.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_non_function_application.snap new file mode 100644 index 00000000000..97fa34c8b9f --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_non_function_application.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "bb62cdfab482aea78d323a917d9bc75e9efa14135ed4f4d8e527f50177ec1de6", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: non-function-appl-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fee669556f73bc23819c313ad93116b621982dbb0b5fed3561b6bc5cc39468a1", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: non-function-appl-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7ea14d508bb5d160d09b89381cf5d3af5856aaa8c9d6e1d9994004315e76bcc0", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: non-function-appl-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "97366806f274eb4a97d48128699e72dbb37b904f3d0e850f2aeaecb80256fc1b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: non-function-appl-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "12f957adfa7b9bfadb4fa9b23659fa9a6f0131ab148872a1a63fbe2b7ceb8335", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: non-function-appl-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ec46182712992e4e4309b8de9daec59789657487586a68ec14c5ae77123d4b20", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: non-function-appl-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3db435c190439ad28695d5f0efd170d62c8c88eb54444af71e2ebfcee9cff418", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: non-function-appl-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting expression of type function) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 747, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_requires_at_most_arguments.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_requires_at_most_arguments.snap new file mode 100644 index 00000000000..01ceed6a2e3 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_requires_at_most_arguments.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "7c4d5ca86ed4a521b0d7a5eda246b2f4c7240a7d2cda8cbc16f78946fb40ea4c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-most-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'principal-construct?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2367, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2367, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f8f8ff3a968b0fabe5cabb37de30a196f59107997dc7c5c2eff75de3e9774261", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-most-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting < 3 arguments, got 4) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2474, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2474, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b4e9343cec29a8c8941c0050c3fca6cc25cd67d8b91464362550251599370784", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-most-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting < 3 arguments, got 4) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2474, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2474, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "486f56246286691e91edebee0e1f42ca54b6baadd7e3932bca2de4901096b0ac", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-most-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'principal-construct?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2367, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2367, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6c152ecdde7f7351bee5d3c2c54e98c502545c4bd844ebe1aee98f3662aa7ef9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-most-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting < 3 arguments, got 4) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2474, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2474, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bb31dfb3fc924e79fa38363f89649688cd6f446ebab42ea9580585a82ab57a6e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-most-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting < 3 arguments, got 4) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2474, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2474, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3865359fdd4453defcd1fb86dd6df4217c505e1096b2897a82a38e3ef6ad3caa", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: requires-at-most-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting < 3 arguments, got 4) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2474, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2474, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_reserved_word.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_reserved_word.snap new file mode 100644 index 00000000000..713f4596393 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_reserved_word.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "34b362f8dadde6564274df15d3dfbeece020b820eaaf9eb7c7e6a1208f049522", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: reserved-word-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(NameAlreadyUsed(\"block-height\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 43, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8876, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 43, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8876, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "99f920c26bd4a742e060b875b0ced655decc3933e5c3d50d4388336a2d9982aa", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: reserved-word-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(NameAlreadyUsed(\"block-height\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 43, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8876, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 43, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8876, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "acc2f2ed02b935702fbfba43a8f48b29d4f63c97ed48ab78d2f9b5860aee6705", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: reserved-word-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: block-height is a reserved word) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1315, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1315, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "42fd9f283ed7ea2b97449bff2c0dedbd4bf4571e5e80c1e704bcca0c46a9574b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: reserved-word-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(NameAlreadyUsed(\"block-height\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 43, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8876, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 43, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8876, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5cb53fbc7b477713aa66e17fd9725c89b75af859f3270c8b0df4a5be43241119", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: reserved-word-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(NameAlreadyUsed(\"block-height\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 43, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8876, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 43, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8876, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "02c2b8607960dabfc8f9ea70c4b1e8af3eba48978b93c867daad5c6b07bf3445", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: reserved-word-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: block-height is a reserved word) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1315, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1315, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "abe1cb127f523f65565ac13a85e24a3f944f5b4bb5389d84916a560f264282e9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: reserved-word-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: block-height is a reserved word) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1315, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1315, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unchecked_intermediary_responses.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unchecked_intermediary_responses.snap new file mode 100644 index 00000000000..37f4414acf9 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unchecked_intermediary_responses.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "a916169f51d9ca161fd19b563bcf411292a43d8d06356444c3b87de71a0ded76", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unchecked-resp-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: intermediary responses in consecutive statements must be checked) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "939dbdab93a12b09a5459cbd3a58dada9b7f1daf311b7e3e7f89c5bade6c8189", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unchecked-resp-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: intermediary responses in consecutive statements must be checked) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bf736c13349973cc228dc940cc281a854359612733dbfeca2af3f7616d0f17ea", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unchecked-resp-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: intermediary responses in consecutive statements must be checked) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a165b27a44372edabec5052d2eb50f529d6ac7a343a029991b2ce2487a049247", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unchecked-resp-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: intermediary responses in consecutive statements must be checked) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d3ebdafa17475e63781e993dcec9f565968ccc81b6504c469415f8c2233bafb0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unchecked-resp-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: intermediary responses in consecutive statements must be checked) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a4a72bce748d3606fe420263d54d91573931413f42b093478079bfe7a1403e5f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unchecked-resp-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: intermediary responses in consecutive statements must be checked) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "281a270fd893840ba5f444f9d6831054ed10d5ba79bd3164c53faa7a8b171630", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unchecked-resp-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: intermediary responses in consecutive statements must be checked) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 13, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3222, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unexpected_trait_or_field_reference.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unexpected_trait_or_field_reference.snap new file mode 100644 index 00000000000..aaabc99f199 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unexpected_trait_or_field_reference.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "21b0259f6ae8687283c48705b73ae6f5182de6970ecf64c66f196f9dafc01542", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-or-field-ref-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: unexpected use of trait reference or field) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5e6c26c312d2fe38726601e0bff0a37865d53a39c9288a066b0853adbbef6f4a", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-or-field-ref-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: unexpected use of trait reference or field) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d730693ac6e76c265241fe6ad09574169add9efe245e366f55b13b6aee1ad52c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-or-field-ref-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: unexpected use of trait reference or field) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b40cb44a62c79f6accb81dbb53771ecbb49703edb815ea68659b0713994f9906", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-or-field-ref-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: unexpected use of trait reference or field) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7268e2a52d17180c4cc3381e6d02e62e3d70018dc1585a0d093ae1fe5a0b9bae", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-or-field-ref-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: unexpected use of trait reference or field) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d67b3e92bd3bc877ed141592946a44c66cd1d3c041ccd8d872b6fa7d5b747fba", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-or-field-ref-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: unexpected use of trait reference or field) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "30e0b9e68ec8f21928009ec7df770da74eee6179213c7b09f1b7763ab0c04733", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-or-field-ref-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: unexpected use of trait reference or field) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1969, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_union_type_error.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_union_type_error.snap new file mode 100644 index 00000000000..e6e96e955a3 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_union_type_error.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "34b362f8dadde6564274df15d3dfbeece020b820eaaf9eb7c7e6a1208f049522", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: union-type-error-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'int\' or \'uint\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "51659c7c2f9db44377c81e683e7eb588e5952d107eb1407cd98ead0832d87242", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: union-type-error-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'int\' or \'uint\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1fea4421fd3c37d2b8520c1219ca5cfb5d8073ee2769c0c76040b815550a7f45", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: union-type-error-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'int\' or \'uint\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fd6f70af0428f1d069caf27a58d1d770c53cba9186d0e657e7e73cc6b1367e49", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: union-type-error-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type \'int\' or \'uint\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9af9258ebd129f0376f5c21f6f5ac8ab1d625a1ea6392ecac3c2d00dd77eece0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: union-type-error-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type \'int\' or \'uint\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b3c72f81a36ba5dbc14b6f57663e95a5a4bb4cc8bf14ac3ae5c2012bc64c4996", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: union-type-error-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type \'int\' or \'uint\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "994ba4061871b5a06ca6eaadf6fd630cc6fe32ce8e20bdca3724d94c1db8b246", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: union-type-error-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting expression of type \'int\' or \'uint\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1532, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unknown_function.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unknown_function.snap new file mode 100644 index 00000000000..1c547596a74 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_unknown_function.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "574fb3537f42b1f49c4b1b4a34ae490de42159cfde951476b9c44ad04ac75f00", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-function-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'ynot\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "01ecbdf6e73b693978c7d8a4d4dddc8021325922e1c1cd3f30c0aae876d1b431", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-function-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'ynot\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7e1dd41a96588b372933b0a76c463a6bca1d44d687adf8954acdb6fae07087e6", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-function-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'ynot\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7ec15e470083a4a5f247419eba10dba4179d404b2e415309ced4c0b6bec93c99", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-function-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'ynot\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4d1c325680c76f2350478021d1f59f0ee1fab9015bc5f3f512914f99a7157fe3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-function-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'ynot\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a17f900c73f4f4d8d297293ed36f0364918fed98f41b1b4657ec3186c5d8afb7", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-function-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'ynot\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2ce6d2d43b4451265996e8ae223f06696303d27ef68f04fe0e87e0f521f779f5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: unknown-function-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: use of unresolved function \'ynot\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 423, + ), + )), +] From 3552d69598c6cd23f771c23b717d62c88a3a4114 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Fri, 7 Nov 2025 10:27:35 +0000 Subject: [PATCH 07/40] add third set of StaticCheckError consensus tests --- clarity-types/src/errors/analysis.rs | 1 + stackslib/src/chainstate/tests/consensus.rs | 132 +++++++++-- ...us__static_check_error_bad_let_syntax.snap | 216 ++++++++++++++++++ ...check_error_expected_list_application.snap | 216 ++++++++++++++++++ ...tatic_check_error_too_many_allowances.snap | 216 ++++++++++++++++++ ...atic_check_error_trait_method_unknown.snap | 216 ++++++++++++++++++ ...c_check_error_trait_reference_unknown.snap | 216 ++++++++++++++++++ ..._error_with_all_allowance_not_allowed.snap | 216 ++++++++++++++++++ ...ck_error_with_all_allowance_not_alone.snap | 216 ++++++++++++++++++ ...ck_error_write_attempted_in_read_only.snap | 216 ++++++++++++++++++ 10 files changed, 1848 insertions(+), 13 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_let_syntax.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_list_application.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_too_many_allowances.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_method_unknown.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_reference_unknown.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_all_allowance_not_allowed.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_all_allowance_not_alone.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_write_attempted_in_read_only.snap diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index 3d93cad713c..b5f42d1671d 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -462,6 +462,7 @@ pub enum StaticCheckErrorKind { /// The `Box` wraps the actual type provided. ExpectedSequence(Box), /// Sequence length exceeds the maximum allowed limit. + /// Unreachable: should exceed u32 elements in memory. MaxLengthOverflow, // Let syntax diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index feb3666d491..1568d330c90 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -1555,8 +1555,17 @@ contract_deploy_consensus_test!( contract_code: "((lambda (x y) 1) 2 1)", ); +// StaticCheckError: [`StaticCheckErrorKind::ExpectedListApplication`] +// Caused by: calling append with lhs that is not a list. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_expected_list_application, + contract_name: "expected-list-appl", + contract_code: "(append 2 3)", +); + // StaticCheckError: [`StaticCheckErrorKind::NoSuchContract`] -// Caused by: +// Caused by: calling contract-call? with a non-existent contract name. // Outcome: block accepted. contract_deploy_consensus_test!( static_check_error_no_such_contract, @@ -1565,7 +1574,7 @@ contract_deploy_consensus_test!( ); // StaticCheckError: [`StaticCheckErrorKind::ContractCallExpectName`] -// Caused by: +// Caused by: calling contract-call? without a contract function name. // Outcome: block accepted. contract_deploy_consensus_test!( static_check_error_contract_call_expect_name, @@ -1629,6 +1638,15 @@ contract_deploy_consensus_test!( contract_code: "(len (list 1) (list 1))", ); +// StaticCheckError: [`StaticCheckErrorKind::BadLetSyntax`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_bad_let_syntax, + contract_name: "bad-let-syntax", + contract_code: "(let 1 2)", +); + // StaticCheckError: [`StaticCheckErrorKind::BadSyntaxBinding`] // Caused by: // Outcome: block accepted. @@ -1718,6 +1736,94 @@ contract_deploy_consensus_test!( contract_code: "(get-burn-block-info? none u1)", ); +// StaticCheckError: [`StaticCheckErrorKind::TraitReferenceUnknown`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_trait_reference_unknown, + contract_name: "trait-ref-unknown", + contract_code: "(+ 1 )", +); + +// StaticCheckError: [`StaticCheckErrorKind::TraitMethodUnknown`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_trait_method_unknown, + contract_name: "trait-method-unknown", + contract_code: " + (define-trait trait-1 ( + (get-1 (uint) (response uint uint)))) + (define-public (wrapped-get-1 (contract )) + (contract-call? contract get-2 u0))", +); + +// StaticCheckError: [`StaticCheckErrorKind::WriteAttemptedInReadOnly`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_write_attempted_in_read_only, + contract_name: "write-attempted-in-ro", + contract_code: " + (define-read-only (silly) + (map-delete map-name (tuple (value 1)))) + (silly)", +); + +// StaticCheckError: [`StaticCheckErrorKind::WithAllAllowanceNotAllowed`] +// Caused by: +// Outcome: block accepted. +// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_with_all_allowance_not_allowed, + contract_name: "all-allow-not-allowed", + contract_code: "(restrict-assets? tx-sender ((with-all-assets-unsafe)) true)", +); + +// StaticCheckError: [`StaticCheckErrorKind::WithAllAllowanceNotAlone`] +// Caused by: +// Outcome: block accepted. +// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_with_all_allowance_not_alone, + contract_name: "all-allow-not-alone", + contract_code: "(as-contract? ((with-all-assets-unsafe) (with-stx u1000)) true)", +); + +// StaticCheckError: [`StaticCheckErrorKind::MaxIdentifierLengthExceeded`] +// Caused by: +// Outcome: block accepted. +// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_max_identifier_length_exceeded, + contract_name: "max-ident-len-excd", + contract_code: &format!( + "(restrict-assets? tx-sender ((with-nft .token \"token-name\" (list {}))) true)", + std::iter::repeat_n("u1", 130) + .collect::>() + .join(" ") + ), +); + +// StaticCheckError: [`StaticCheckErrorKind::TooManyAllowances`] +// Caused by: +// Outcome: block accepted. +// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_too_many_allowances, + contract_name: "too-many-allowances", + contract_code: &format!( + "(restrict-assets? tx-sender ({} ) true)", + std::iter::repeat_n("(with-stx u1)", 130) + .collect::>() + .join(" ") + ), +); + // pub enum StaticCheckErrorKind { // CostOverflow, // CostBalanceExceeded(ExecutionCost, ExecutionCost), @@ -1780,12 +1886,12 @@ contract_deploy_consensus_test!( // GetStacksBlockInfoExpectPropertyName, // GetTenureInfoExpectPropertyName, // NameAlreadyUsed(String), [`static_check_error_name_already_used`] -// ReservedWord(String), +// ReservedWord(String), [`static_check_error_reserved_word`] // NonFunctionApplication, [`static_check_error_non_function_application`] -// ExpectedListApplication, +// ExpectedListApplication, [`static_check_error_expected_list_application`] // ExpectedSequence(Box), [`static_check_error_expected_sequence`] -// MaxLengthOverflow, -// BadLetSyntax, +// MaxLengthOverflow, UNREACHABLE: should exceed u32 elements in memory. +// BadLetSyntax, [`static_check_error_bad_let_syntax`] // BadSyntaxBinding(SyntaxBindingError), [`static_check_error_bad_syntax_binding`] // MaxContextDepthReached, // UndefinedVariable(String), [`static_check_error_undefined_variable`] @@ -1798,8 +1904,8 @@ contract_deploy_consensus_test!( // IllegalOrUnknownFunctionApplication(String), [`static_check_error_illegal_or_unknown_function_application`] // UnknownFunction(String), [`static_check_error_unknown_function`] // NoSuchTrait(String, String), -// TraitReferenceUnknown(String), -// TraitMethodUnknown(String, String), +// TraitReferenceUnknown(String), [`static_check_error_trait_reference_unknown`] +// TraitMethodUnknown(String, String), [`static_check_error_trait_method_unknown`] // ExpectedTraitIdentifier, // BadTraitImplementation(String, String), // DefineTraitBadSignature, [`static_check_error_define_trait_bad_signature`] @@ -1807,14 +1913,14 @@ contract_deploy_consensus_test!( // UnexpectedTraitOrFieldReference, [`static_check_error_unexpected_trait_or_field_reference`] // ContractOfExpectsTrait, // IncompatibleTrait(Box, Box), [`static_check_error_incompatible_trait`] -// WriteAttemptedInReadOnly, +// WriteAttemptedInReadOnly, [`static_check_error_write_attempted_in_read_only`] // AtBlockClosureMustBeReadOnly, // ExpectedListOfAllowances(String, i32), // AllowanceExprNotAllowed, // ExpectedAllowanceExpr(String), -// WithAllAllowanceNotAllowed, -// WithAllAllowanceNotAlone, +// WithAllAllowanceNotAllowed, [`static_check_error_with_all_allowance_not_allowed`] +// WithAllAllowanceNotAlone, [`static_check_error_with_all_allowance_not_alone`] // WithNftExpectedListOfIdentifiers, -// MaxIdentifierLengthExceeded(u32, u32), -// TooManyAllowances(usize, usize), +// MaxIdentifierLengthExceeded(u32, u32), [`static_check_error_max_identifier_length_exceeded`] +// TooManyAllowances(usize, usize), [`static_check_error_too_many_allowances`] // } diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_let_syntax.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_let_syntax.snap new file mode 100644 index 00000000000..2170cbf0661 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_let_syntax.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "c043bd4d6a38f46727e3be3aa60d256258fd1f1fc72baffd8380c50c9ad37a2b", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-let-syntax-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid syntax of \'let\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ca408e955d23b19587054363d1b16fb90cfd6ed7f377ebe0a6bd67c6a78531d1", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-let-syntax-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid syntax of \'let\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a6d6bc582c79f30d1be39ca3ecb4f7233a50a63ea6e568e61db52cfe152aa215", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-let-syntax-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid syntax of \'let\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "922a7ca0bdbab58aba82b58d59429a6f1c4439ab28a33274a426fb0c9021d0bf", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-let-syntax-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid syntax of \'let\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "77786a11754d7680ed2b01763ee9c13c8738cf59a27a87ed1f7aef3844102721", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-let-syntax-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid syntax of \'let\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "58ee4de469092fb33bfd81d5b21d44723e6966c532a7693be93b259386488cbf", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-let-syntax-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid syntax of \'let\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "70613ef4f322af59b528986cbfcdb45128009586f991ec1dddceec0b312441f3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-let-syntax-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: invalid syntax of \'let\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 396, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_list_application.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_list_application.snap new file mode 100644 index 00000000000..03621a205ca --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_list_application.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "20c5afd9821d7beb28daa33b747ed2c73cf388d928576ea98b85a0e404114158", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-list-appl-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a45206ae3db6ad9d1d7626966b2a6575cc61f3cf20b8112ce43688d945ca6a23", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-list-appl-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "23bd5d9ff8bfccdbf3865bde4f1b7bec978a973605fa1214c92088ed1eef0166", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-list-appl-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7d2243c735e54695a4e00ca969f7a6b619d7db947e050ce7ff343a3ac340d4f4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-list-appl-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting expression of type list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e334410ac7e5fdb3f27699734498d91dbdccb270aacbe1cca12296624ad8f979", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-list-appl-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting expression of type list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "af36ae90a68618452cca04c339900eecf55c6aa0996990510b9375855f0e864d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-list-appl-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting expression of type list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c9f61c138e0752ccedeb682d4cda37e9d550d834e2d5e520f1fbfbe221135c0e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-list-appl-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting expression of type list) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_too_many_allowances.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_too_many_allowances.snap new file mode 100644 index 00000000000..c11e38e6b69 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_too_many_allowances.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "7368416a46a31bf20278d82a47815d3f2ae8e9e34e1e0df895e36df2906a2250", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-allowances-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "63d8ff4ef1d36e1c56425acdda7cc8f6a7f31cc1924d7a7d4d1a13af9d4e5b83", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-allowances-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4c075f4e0eace2dcdf8885565387f27cc03144edc64a911656410e5d7d765d8e", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-allowances-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "82d6784037f29eec61b1f3e2bd9e9d16869a4d0adbb1b3454beb5028f5bc754a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-allowances-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6cb54ff53ff5604a9118665fe2ec4194aeaa9d4ab86392b8f46c78e66c3b0a56", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-allowances-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3a820cff7df1b40d541548b1df1d969a0e5f9b9b869c16d7be1b53fbe2150121", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-allowances-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 50265, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "94dbeb2b7f039f7f2f8224b9f005b6ff11ae5d1ea9f3aadbe2825121d602e1d1", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-allowances-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: too many allowances specified, the maximum is 128, found 130) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 396, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 51150, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 396, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 51150, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_method_unknown.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_method_unknown.snap new file mode 100644 index 00000000000..dfed7eb5bd7 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_method_unknown.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "297dc663ad7d847523569414c9d38841085bc400785f4f6ddd860fc1b221f1f5", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-method-unknown-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: method \'get-2\' unspecified in trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "072e24a7887a0e5e295368d029ca6f5c4fe81be5fd9756b1c554500ca9e09459", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-method-unknown-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: method \'get-2\' unspecified in trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6e6a1fbc906c852f9dbb41727694719ba31a10d015a88bec1f625a7b8b661647", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-method-unknown-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: method \'get-2\' unspecified in trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8f98efc3d0e9902aff899d3acf8c953bfa85b5c44777bd0c320f5438ac5d4f6a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-method-unknown-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: method \'get-2\' unspecified in trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7419f752c49f9f5076b396606195981cf117590f7609738542af264aa5b9761e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-method-unknown-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: method \'get-2\' unspecified in trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ff6457573bdd9bfd55e5a26f4048ffaf7584ad64caa93c1e2581a221792c80d2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-method-unknown-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: method \'get-2\' unspecified in trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "230b23e7a9c2f25bae550e4ca51e66fb671599e3bee6997423b754b008a14082", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-method-unknown-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: method \'get-2\' unspecified in trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 25, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 5648, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_reference_unknown.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_reference_unknown.snap new file mode 100644 index 00000000000..0d719d6181a --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_reference_unknown.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "6ddddd31a195785e558a0f2f17720c651438cc145eaf2cf654e7c008baff8107", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-ref-unknown-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(use of undeclared trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "890c3494599500568f19363ec868e1c4dea6578aa43c05f548f5dacfdb2c2934", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-ref-unknown-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(use of undeclared trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b3e6c76df75e1cbd5aedb2ac74e4958134bb6cfd4ad09dfde004b4102165a47e", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-ref-unknown-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(use of undeclared trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "42db1e8cc2bd8baff03a3b27e5ba930adbf3a01d1d660eff0600793af152a835", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-ref-unknown-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(use of undeclared trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "104a50f711d852f1dc86eed8ffbe21f4c7fcf87b61b71d7aa0d4a88c198e5713", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-ref-unknown-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(use of undeclared trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4a4155416398a49277ac770cad673898e5eb78d5da65d080b54f0d59f8e16f6c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-ref-unknown-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(use of undeclared trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8f7be76cade0dd53de731dd71ff3effff30c464b08b396c0a77aac31531173ce", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-ref-unknown-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(use of undeclared trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 558, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_all_allowance_not_allowed.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_all_allowance_not_allowed.snap new file mode 100644 index 00000000000..f1408df4ab4 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_all_allowance_not_allowed.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "cd49f2506148db603f0bcad965dfca47d1d758b2562b4f546c20f5fcdcfff9c6", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-allowed-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d3433669eadfc24c9b1653fe0c7958b8e6f4750dd147e18f658ff399257c1198", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-allowed-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b9d109ee3e25ec35472c6822b7822bc2d2a8237a97f6fbb388d0af78629cb08e", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-allowed-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "579f1ca6007598ef1d46187dac88c20808e6eabe7c51a3ec2258cf3ca081b485", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-allowed-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d19630d278070609589c51ffd722bdc60ae5efcd265ec541aeb8c9eb479fe977", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-allowed-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "900b3c6746ec3f91ea57df95df3d8a19a32864b20f4b48160fee13028f55430f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-allowed-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1773, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4082cc1f0f2b4a783d5715e52f639afad95d1cef75072a2181d053212571d6c4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-allowed-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: with-all-assets-unsafe is not allowed here, only in the allowance list for `as-contract?`) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 8, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2029, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 8, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2029, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_all_allowance_not_alone.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_all_allowance_not_alone.snap new file mode 100644 index 00000000000..e0d3f411406 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_all_allowance_not_alone.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "21b0259f6ae8687283c48705b73ae6f5182de6970ecf64c66f196f9dafc01542", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-alone-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'as-contract?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2557d85a29dbc28b38fdd846aa8f1d60fe443bebd22b8ff62d69981867cae0a2", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-alone-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'as-contract?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3a4ac757e1eedfca1cdc70441dee1121665455ad235be6ccea2a9f6c4921f72d", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-alone-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'as-contract?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7e58d9f64836642717ce054a91b5a614c32da860a2d11f5426f4adbae5494d72", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-alone-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'as-contract?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6c0707eeaf04d9e9bc5207cb375ea4c4672b883d33d6909f4c2f22ca50b78c29", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-alone-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'as-contract?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0ff48515127f76d8812507a3e429dca18a5d46eb156839c2eb971832e269b338", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-alone-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'as-contract?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1854, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9c6e3887d27d0c6fdbae353596159fa89990a4a6f674a4399b5d908ee7cd887e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: all-allow-not-alone-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: with-all-assets-unsafe must not be used along with other allowances) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1977, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 10, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1977, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_write_attempted_in_read_only.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_write_attempted_in_read_only.snap new file mode 100644 index 00000000000..73ac3bdb35d --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_write_attempted_in_read_only.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "f88853f28589138bba61c8ae0c870663b52ce55ff301906ff86e497cf168f2ac", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: write-attempted-in-ro-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting read-only statements, detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "09fcbc52e762419538190ce598721405b9164f982b0a2d4f2206009d64dd7c64", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: write-attempted-in-ro-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting read-only statements, detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1507ec3dfb86e240f3e9f7b163a5af177a4a916f98e4d1aae9c81be097741930", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: write-attempted-in-ro-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting read-only statements, detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "60f13673eadd008733f4fc394a91f8fb47bef07a7fec50bb7c367543a0b42127", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: write-attempted-in-ro-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting read-only statements, detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "46af6d77f035ad6a3fa99b02b19742aeea1d331baa33f2f3b4eb11f8f646fb61", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: write-attempted-in-ro-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting read-only statements, detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3dd7b4214c1ee539efff7ff6ea41ed6d5f2555822d113777fe51b741038ce371", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: write-attempted-in-ro-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting read-only statements, detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c4b635df09020ab19007974d92b4a0212322a4f5ef7c7868c1164f0e8c67459f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: write-attempted-in-ro-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting read-only statements, detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3075, + ), + )), +] From b70de54b30d4dc2a604f531d27f3da1f7f57e6db Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Fri, 7 Nov 2025 17:23:59 +0000 Subject: [PATCH 08/40] add fourth set of StaticCheckError consensus tests --- clarity-types/src/errors/analysis.rs | 22 +- stackslib/src/chainstate/tests/consensus.rs | 186 ++++++++++++--- ..._static_check_error_bad_function_name.snap | 216 ++++++++++++++++++ ...nsus__static_check_error_bad_map_name.snap | 216 ++++++++++++++++++ ...ic_check_error_bad_tuple_construction.snap | 216 ++++++++++++++++++ ...atic_check_error_bad_tuple_field_name.snap | 216 ++++++++++++++++++ ...k_error_define_function_bad_signature.snap | 216 ++++++++++++++++++ ...us__static_check_error_expected_tuple.snap | 216 ++++++++++++++++++ ...r_get_block_info_expect_property_name.snap | 216 ++++++++++++++++++ ..._burn_block_info_expect_property_name.snap | 216 ++++++++++++++++++ ...tacks_block_info_expect_property_name.snap | 216 ++++++++++++++++++ ..._get_tenure_info_expect_property_name.snap | 216 ++++++++++++++++++ ..._error_max_identifier_length_exceeded.snap | 216 ++++++++++++++++++ ...ensus__static_check_error_no_such_map.snap | 216 ++++++++++++++++++ ...or_no_such_stacks_block_info_property.snap | 216 ++++++++++++++++++ ...ck_error_no_such_tenure_info_property.snap | 216 ++++++++++++++++++ ...tatic_check_error_no_such_tuple_field.snap | 216 ++++++++++++++++++ 17 files changed, 3415 insertions(+), 33 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_function_name.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_map_name.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_tuple_construction.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_tuple_field_name.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_function_bad_signature.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_tuple.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_block_info_expect_property_name.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_burn_block_info_expect_property_name.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_stacks_block_info_expect_property_name.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_tenure_info_expect_property_name.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_max_identifier_length_exceeded.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_map.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_stacks_block_info_property.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_tenure_info_property.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_tuple_field.snap diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index b5f42d1671d..2348c57e242 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -248,6 +248,9 @@ pub enum CommonCheckErrorKind { IncorrectArgumentCount(usize, usize), /// Expected a trait identifier (e.g., `.trait-name`) but found an invalid token. + /// Unreachable: Before type-checking runs, if there is a (use-trait …) or (impl-trait …) with an + /// invalid second argument is present, it will be caught by the parser and raise a + /// [`ParseErrorKind::ImportTraitBadSignature`] or [`ParseErrorKind::ImplTraitBadSignature`]. ExpectedTraitIdentifier, /// Invalid or malformed signature in a `(define-trait ...)` expression. DefineTraitBadSignature, @@ -345,15 +348,18 @@ pub enum StaticCheckErrorKind { UncheckedIntermediaryResponses, // Match type errors - /// Could not determine the types for a match expression’s branches. + /// Could not determine the types for a match expression's branches. CouldNotDetermineMatchTypes, /// Could not determine the type of an expression during analysis. CouldNotDetermineType, - // Checker runtime failures + // Checker failures /// Attempt to re-annotate a type that was already annotated, indicating a bug. + /// Unreachable: The AST assigner gives each node a unique `id`, and the type checker visits + /// each node exactly once, so duplicate annotations cannot occur. TypeAlreadyAnnotatedFailure, /// Unexpected failure in the type-checker implementation, indicating a bug. + /// Unreachable. CheckerImplementationFailure, // Assets @@ -375,7 +381,7 @@ pub enum StaticCheckErrorKind { /// The `Box` wraps the actual type provided. ExpectedTuple(Box), /// Referenced tuple field does not exist in the tuple type. - /// The `String` wraps the requested field name, and the `TupleTypeSignature` wraps the tuple’s type. + /// The `String` wraps the requested field name, and the `TupleTypeSignature` wraps the tuple's type. NoSuchTupleField(String, TupleTypeSignature), /// Empty tuple is not allowed in Clarity. EmptyTuplesNotAllowed, @@ -474,7 +480,10 @@ pub enum StaticCheckErrorKind { /// The `SyntaxBindingError` wraps the specific binding error. BadSyntaxBinding(SyntaxBindingError), - /// Maximum context depth for type-checking has been reached. + /// Maximum context depth of [`MAX_CONTEXT_DEPTH`] for type-checking has been reached. + /// Unreachable: Before type checking runs, the parser enforces an AST nesting limit of + /// [`AST_CALL_STACK_DEPTH_BUFFER`] + [`MAX_CALL_STACK_DEPTH`] (5 + 64). Any contract + /// exceeding depth 69 fails with [`ParseErrorKind::ExpressionStackDepthTooDeep`]. MaxContextDepthReached, /// Referenced variable is not defined in the current scope. /// The `String` wraps the non-existent variable name. @@ -509,6 +518,9 @@ pub enum StaticCheckErrorKind { // Traits /// Referenced trait does not exist in the specified contract. /// The first `String` wraps the contract name, and the second wraps the trait name. + /// Unreachable: all trait identifiers are validated by the parser and TraitsResolver + /// before type checking; invalid or missing traits trigger TraitReferenceUnknown + /// earlier, so this error is never returned. NoSuchTrait(String, String), /// Referenced trait is not defined or cannot be found. /// The `String` wraps the non-existent trait name. @@ -686,7 +698,7 @@ pub enum CheckErrorKind { /// The `Box` wraps the actual type provided. ExpectedTuple(Box), /// Referenced tuple field does not exist in the tuple type. - /// The `String` wraps the requested field name, and the `TupleTypeSignature` wraps the tuple’s type. + /// The `String` wraps the requested field name, and the `TupleTypeSignature` wraps the tuple's type. NoSuchTupleField(String, TupleTypeSignature), /// Empty tuple is not allowed in Clarity. EmptyTuplesNotAllowed, diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index 1568d330c90..5730c4c4906 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -1620,15 +1620,6 @@ contract_deploy_consensus_test!( contract_code: "(ynot 1 2)", ); -// // StaticCheckError: [`StaticCheckErrorKind::UTraitReferenceUnknownnknownFunction`] -// // Caused by: -// // Outcome: block accepted. -// contract_deploy_consensus_test!( -// static_check_error_trait_reference_unknown, -// contract_name: "trait-ref-unknown", -// contract_code: "", -// ); - // StaticCheckError: [`StaticCheckErrorKind::IncorrectArgumentCount`] // Caused by: // Outcome: block accepted. @@ -1700,6 +1691,7 @@ contract_deploy_consensus_test!( // StaticCheckError: [`StaticCheckErrorKind::IncompatibleTrait`] // Caused by: pass a trait to a trait parameter which is not compatible. // Outcome: block accepted. +// Note: Added in Clarity 2. Clarity 1 will trigger a [`StaticCheckErrorKind::TypeError`]. contract_deploy_consensus_test!( static_check_error_incompatible_trait, contract_name: "incompatible-trait", @@ -1736,6 +1728,28 @@ contract_deploy_consensus_test!( contract_code: "(get-burn-block-info? none u1)", ); +// StaticCheckError: [`StaticCheckErrorKind::NoSuchStacksBlockInfoProperty`] +// Caused by: +// Outcome: block accepted. +// Note: This error was added in Clarity 3. Clarity 1, and 2 +// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_no_such_stacks_block_info_property, + contract_name: "no-such-stacks-info", + contract_code: "(get-stacks-block-info? none u1)", +); + +// StaticCheckError: [`StaticCheckErrorKind::NoSuchTenureInfoProperty`] +// Caused by: +// Outcome: block accepted. +// Note: This error was added in Clarity 3. Clarity 1, and 2 +// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_no_such_tenure_info_property, + contract_name: "no-such-tenure-info", + contract_code: "(get-tenure-info? none u1)", +); + // StaticCheckError: [`StaticCheckErrorKind::TraitReferenceUnknown`] // Caused by: // Outcome: block accepted. @@ -1824,6 +1838,122 @@ contract_deploy_consensus_test!( ), ); +// StaticCheckError: [`StaticCheckErrorKind::BadTupleConstruction`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_bad_tuple_construction, + contract_name: "bad-tuple-constr", + contract_code: "(tuple (name 1) (name 2))", +); + +// StaticCheckError: [`StaticCheckErrorKind::ExpectedTuple`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_expected_tuple, + contract_name: "expected-tuple", + contract_code: "(get field-0 (some 1))", +); + +// StaticCheckError: [`StaticCheckErrorKind::NoSuchTupleField`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_no_such_tuple_field, + contract_name: "no-such-tuple-f", + contract_code: "(get value (tuple (name 1)))", +); + +// StaticCheckError: [`StaticCheckErrorKind::NoSuchMap`] +// Caused by: +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_no_such_map, + contract_name: "no-such-map", + contract_code: "(map-get? non-existent (tuple (name 1)))", +); + +// StaticCheckError: [`StaticCheckErrorKind::BadFunctionName`] +// Caused by: defining a function whose signature does not start with an atom name. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_bad_function_name, + contract_name: "bad-func-name", + contract_code: "(define-private (u1) u0)", +); + +// StaticCheckError: [`StaticCheckErrorKind::DefineFunctionBadSignature`] +// Caused by: defining a function with an empty signature list. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_define_function_bad_signature, + contract_name: "def-func-bad-sign", + contract_code: "(define-private () 1)", +); + +// StaticCheckError: [`StaticCheckErrorKind::BadTupleFieldName`] +// Caused by: using `(get ...)` with a tuple field argument that is not an atom. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_bad_tuple_field_name, + contract_name: "bad-tuple-field-name", + contract_code: "(get u1 (tuple (foo u0)))", +); + +// StaticCheckError: [`StaticCheckErrorKind::BadMapName`] +// Caused by: passing a literal instead of a map identifier to `map-get?`. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_bad_map_name, + contract_name: "bad-map-name", + contract_code: "(map-get? u1 (tuple (id u0)))", +); + +// StaticCheckError: [`StaticCheckErrorKind::GetBlockInfoExpectPropertyName`] +// Caused by: calling `get-block-info` with a non-atom property argument. +// Outcome: block accepted. +// Note: Only Clarity 1 and 2 will trigger this error. Clarity 3 and 4 +// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_get_block_info_expect_property_name, + contract_name: "info-exp-prop-name", + contract_code: "(get-block-info? u1 u0)", +); + +// StaticCheckError: [`StaticCheckErrorKind::GetBurnBlockInfoExpectPropertyName`] +// Caused by: calling `get-burn-block-info` with a non-atom property argument. +// Outcome: block accepted. +// Note: This error was added in Clarity 2. Clarity 1 will trigger +// a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_get_burn_block_info_expect_property_name, + contract_name: "burn-exp-prop-name", + contract_code: "(get-burn-block-info? u1 u0)", +); + +// StaticCheckError: [`StaticCheckErrorKind::GetStacksBlockInfoExpectPropertyName`] +// Caused by: calling `get-stacks-block-info` with a non-atom property argument. +// Outcome: block accepted. +// Note: This error was added in Clarity 3. Clarity 1 and 2 will trigger +// a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_get_stacks_block_info_expect_property_name, + contract_name: "stacks-exp-prop-name", + contract_code: "(get-stacks-block-info? u1 u0)", +); + +// StaticCheckError: [`StaticCheckErrorKind::GetTenureInfoExpectPropertyName`] +// Caused by: calling `get-tenure-info` with a non-atom property argument. +// Outcome: block accepted. +// Note: This error was added in Clarity 3. Clarity 1 and 2 will trigger +// a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_get_tenure_info_expect_property_name, + contract_name: "tenure-exp-prop-name", + contract_code: "(get-tenure-info? u1 u0)", +); + // pub enum StaticCheckErrorKind { // CostOverflow, // CostBalanceExceeded(ExecutionCost, ExecutionCost), @@ -1853,22 +1983,22 @@ contract_deploy_consensus_test!( // UncheckedIntermediaryResponses, [`static_check_error_unchecked_intermediary_responses`] // CouldNotDetermineMatchTypes, [`static_check_error_could_not_determine_match_types`] // CouldNotDetermineType, [`static_check_error_could_not_determine_type`] -// TypeAlreadyAnnotatedFailure, -// CheckerImplementationFailure, +// TypeAlreadyAnnotatedFailure, // Unreachable: The AST assigner gives each node a unique `id`, and the type checker visits each node exactly once, so duplicate annotations cannot occur. +// CheckerImplementationFailure, // Unreachable // BadTokenName, [`static_check_error_bad_token_name`] // DefineNFTBadSignature, [`static_check_error_define_nft_bad_signature`] // NoSuchNFT(String), [`static_check_error_no_such_nft`] // NoSuchFT(String), [`static_check_error_no_such_ft`] -// BadTupleFieldName, -// ExpectedTuple(Box), -// NoSuchTupleField(String, TupleTypeSignature), +// BadTupleFieldName, [`static_check_error_bad_tuple_field_name`] +// ExpectedTuple(Box), [`static_check_error_expected_tuple`] +// NoSuchTupleField(String, TupleTypeSignature), [`static_check_error_no_such_tuple_field`] // EmptyTuplesNotAllowed, [`static_check_error_empty_tuples_not_allowed`] -// BadTupleConstruction(String), +// BadTupleConstruction(String), [`static_check_error_bad_tuple_construction`] // NoSuchDataVariable(String), [`static_check_error_no_such_data_variable`] -// BadMapName, -// NoSuchMap(String), -// DefineFunctionBadSignature, -// BadFunctionName, +// BadMapName, [`static_check_error_bad_map_name`] +// NoSuchMap(String), [`static_check_error_no_such_map`] +// DefineFunctionBadSignature, [`static_check_error_define_function_bad_signature`] +// BadFunctionName, [`static_check_error_bad_function_name`] // BadMapTypeDefinition, [`static_check_error_bad_map_type_definition`] // PublicFunctionMustReturnResponse(Box), // DefineVariableBadSignature, [`static_check_error_define_variable_bad_signature`] @@ -1879,12 +2009,12 @@ contract_deploy_consensus_test!( // ContractCallExpectName, [`static_check_error_contract_call_expect_name`] // ExpectedCallableType(Box), // NoSuchBlockInfoProperty(String), [`static_check_error_no_such_block_info_property`] -// NoSuchStacksBlockInfoProperty(String), -// NoSuchTenureInfoProperty(String), -// GetBlockInfoExpectPropertyName, -// GetBurnBlockInfoExpectPropertyName, -// GetStacksBlockInfoExpectPropertyName, -// GetTenureInfoExpectPropertyName, +// NoSuchStacksBlockInfoProperty(String), [`static_check_error_no_such_stacks_block_info_property`] +// NoSuchTenureInfoProperty(String), [`static_check_error_no_such_tenure_info_property`] +// GetBlockInfoExpectPropertyName, [`static_check_error_get_block_info_expect_property_name`] +// GetBurnBlockInfoExpectPropertyName, [`static_check_error_get_burn_block_info_expect_property_name`] +// GetStacksBlockInfoExpectPropertyName, [`static_check_error_get_stacks_block_info_expect_property_name`] +// GetTenureInfoExpectPropertyName, [`static_check_error_get_tenure_info_expect_property_name`] // NameAlreadyUsed(String), [`static_check_error_name_already_used`] // ReservedWord(String), [`static_check_error_reserved_word`] // NonFunctionApplication, [`static_check_error_non_function_application`] @@ -1893,7 +2023,7 @@ contract_deploy_consensus_test!( // MaxLengthOverflow, UNREACHABLE: should exceed u32 elements in memory. // BadLetSyntax, [`static_check_error_bad_let_syntax`] // BadSyntaxBinding(SyntaxBindingError), [`static_check_error_bad_syntax_binding`] -// MaxContextDepthReached, +// MaxContextDepthReached, /// Unreachable: Before type checking runs, the parser enforces an AST nesting limit of (5 + 64). Any contract exceeding depth 69 fails with [`ParseErrorKind::ExpressionStackDepthTooDeep`]. // UndefinedVariable(String), [`static_check_error_undefined_variable`] // RequiresAtLeastArguments(usize, usize), [`static_check_error_requires_at_least_arguments`] // RequiresAtMostArguments(usize, usize), [`static_check_error_requires_at_most_arguments`] @@ -1903,10 +2033,10 @@ contract_deploy_consensus_test!( // DefaultTypesMustMatch(Box, Box), [`static_check_error_default_types_must_match`] // IllegalOrUnknownFunctionApplication(String), [`static_check_error_illegal_or_unknown_function_application`] // UnknownFunction(String), [`static_check_error_unknown_function`] -// NoSuchTrait(String, String), +// NoSuchTrait(String, String), // Unreachable: all trait identifiers are validated by the parser and TraitsResolve before type checking; invalid or missing traits trigger TraitReferenceUnknown earlier, so this error is never returned. // TraitReferenceUnknown(String), [`static_check_error_trait_reference_unknown`] // TraitMethodUnknown(String, String), [`static_check_error_trait_method_unknown`] -// ExpectedTraitIdentifier, +// ExpectedTraitIdentifier, // Unreachable: (use-trait …) or (impl-trait …) with an invalid second argument fails in the AST stage, raising ParseErrorKind::ImportTraitBadSignature/ImplTraitBadSignature before static checks run. // BadTraitImplementation(String, String), // DefineTraitBadSignature, [`static_check_error_define_trait_bad_signature`] // DefineTraitDuplicateMethod(String), [`static_check_error_define_trait_duplicate_method`] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_function_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_function_name.snap new file mode 100644 index 00000000000..82f105a7dc4 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_function_name.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "503019f3be7848862c59c2c95182cf38f978d976e72025075e64bab14cb2af93", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-func-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid function name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1cd94e0dd8f92a919a8e9d745011ebe84352c855f8598af33179c2cde7aaa17f", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-func-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid function name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1aa9398462e986091fb3a40fac166847439dfa68043ab8b5f0f6bc285e292bce", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-func-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid function name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f3edf1ec80e697bc858bba36cc91cdb5e284333efc4698502fe94cf8804a4ff6", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-func-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid function name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "75b86a3a2da91ed02a799302504485c4f71c5ac792cd7101278b9c35df625000", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-func-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid function name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9a7a638c2fa4bd1d45520bc0939a07eb74730d4ae036f93958e1a43fc29275dd", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-func-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid function name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1c8d4e93cfb0866ec7be7e05deaed3414f75857925d69f04d4c97a8c1b647008", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-func-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: invalid function name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_map_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_map_name.snap new file mode 100644 index 00000000000..0363123a236 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_map_name.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "7f15bb069bea6c767d55397e51f6d764a13e6173b004fa4d2431dcd70fc8d15c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid map name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9998e5d1cdf731da9333aef3b944384bfd9c58e2e24279377781b7e342c54feb", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid map name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "59bb1b7d9037c1cbe0bfe3ebcdfb419b321c8d7a08fff0f12514a22d7f972fb8", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid map name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2bb72e6d97fc0f193b94f101db8f94a580dfad274e336c8a12b8fcc5c4aab4da", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid map name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3cc7ed2a05dd4b7be301ac340ffd62c8e1970949920263691af53803c37c5251", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid map name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "12fcbf5b42e397aa06ed486c2dbf0a2597ac9e24033634aa8687ee07b1647949", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid map name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "df61ba29a6cb3256fc56901aab2933e0b33f0dc9af09be6aae9a46dd92c027a9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-map-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: invalid map name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1047, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_tuple_construction.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_tuple_construction.snap new file mode 100644 index 00000000000..37a544a2377 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_tuple_construction.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5ad517322daee7a5aaca3c7cbbc0bcdefa9a3445e082cd183f627f5bc844e123", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-constr-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid tuple syntax: defining \'name\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8414a9390fca3c44f98dde948af67824a94dfab7c6814cb6f770e554b658a2c1", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-constr-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid tuple syntax: defining \'name\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8df214cdfe2a91346a56ab4eb17d3b8fe077f8fe4f31defacf16cdf1a011333c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-constr-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid tuple syntax: defining \'name\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c4a093f900d197e7442a232783711a2a811b446a7959b78b98e1956fd3bdcd8a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-constr-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid tuple syntax: defining \'name\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "75c1199ca124ab3ee55a5a1c0d07d7645e3a8d59db0709a5c535ebede59b938c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-constr-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid tuple syntax: defining \'name\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d032631f1952bbe873f8cfd56b05b92e492f1ba381782a49b0032fdbdfc5b694", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-constr-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid tuple syntax: defining \'name\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "685b6dd0601d0845238543708d927a7451a649548476c903f16ecfc4ddf327a2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-constr-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: invalid tuple syntax: defining \'name\' conflicts with previous value) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1030, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_tuple_field_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_tuple_field_name.snap new file mode 100644 index 00000000000..48d0573f726 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_tuple_field_name.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5ad517322daee7a5aaca3c7cbbc0bcdefa9a3445e082cd183f627f5bc844e123", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-field-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid tuple field name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4ff7192c27a26970f98d7b49ae38776c40763994a647312b5b2f18078878ffc4", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-field-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid tuple field name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4a74c1cd34277a825272fcbdddb73d0d2c115554a1eca4633ab36ead21117cb7", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-field-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid tuple field name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e3179f438bcc59bcd27e4d280ce6185fe66365b9f2d427744a64714e63f51d47", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-field-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid tuple field name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7e9e581c333cdad8b5bcc9af08d06c1e4c042ffd147e1f03d43baf401a490611", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-field-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid tuple field name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b8226f9e10c8ce23f4925b752556f52f70136e1e882fa1d74fa8bbf4f4fe97cb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-field-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid tuple field name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8e37c4e56e023597293325e464b3a2e521828098f513eecbab5a20a6834b698d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: bad-tuple-field-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: invalid tuple field name) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 939, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_function_bad_signature.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_function_bad_signature.snap new file mode 100644 index 00000000000..69ed7a0dc82 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_define_function_bad_signature.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "7460df2e55d8ae81ddd024f9b80f532ce3d75c0cf7dc690f659a2d842a360db9", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-func-bad-sign-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid function definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b5ea0eba4e0cef51a0d73b1c373802784d300816073027b0a3bc7231556cfc92", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-func-bad-sign-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid function definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8b82841da33b91005ed5df75847599cb56794e01e97d5c4753e58d6940c03e8e", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-func-bad-sign-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid function definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c5ec7def34ab8d658c594b05bf586e2b8f9a8c2630d311c987e26d15bce87d7c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-func-bad-sign-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: invalid function definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "19660e0bfdc63266def8077920d279fee8a428a9f4d878e8e8fcb80e9c944994", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-func-bad-sign-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: invalid function definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b860154a82ad463a31ec662a0efc15ea18712ceff26cbbb1a9700b4784ec77f6", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-func-bad-sign-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: invalid function definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "99e9fc49326a88fc6cdd4d9523274bd15cd96992560f1874d4e991b1008868b2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: def-func-bad-sign-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: invalid function definition) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 720, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_tuple.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_tuple.snap new file mode 100644 index 00000000000..e6964c88588 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_tuple.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "bb62cdfab482aea78d323a917d9bc75e9efa14135ed4f4d8e527f50177ec1de6", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-tuple-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting tuple, found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6f8c79692c070ce5c5ec2164327e37a722be9e3352ecd9a9f856ff2c61ca1b7a", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-tuple-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting tuple, found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "37106f9a1b182df335f532735b1dbc67308bf76d8c05245e549810688a3269a4", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-tuple-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting tuple, found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ccae120c018aff26e0bead19f5ad0a20e21df08bb67a369013490a5820498430", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-tuple-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: expecting tuple, found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c7fa609f590df18d4296c57427e2cf5af4d293b9089010fd53d27666980bf1d7", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-tuple-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expecting tuple, found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "da3ee584e8595ecd059f6f75a42ca70705b44fadd7a94ed75b0861c6ec6212d2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-tuple-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expecting tuple, found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ca746c88e8c5a5da0b57a39a38ea13a9921606d9a171e67c12b43467027a5d33", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expected-tuple-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expecting tuple, found \'int\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 7, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 882, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_block_info_expect_property_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_block_info_expect_property_name.snap new file mode 100644 index 00000000000..88521ae1241 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_block_info_expect_property_name.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "f66cce81e51343282596b8c2ce5e59e61090471ddb0901e3dbf5ccaa045429e3", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: info-exp-prop-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: missing property name for block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 877, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 877, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "09571a8539b7bfbc35731dcc381681cef2e621d292d434141a186a580e743ebc", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: info-exp-prop-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: missing property name for block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 877, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 877, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "69dca1c762bf18f8392b6434c8c01b932bf18f220c0d8f051e6d3a520fdcacec", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: info-exp-prop-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'get-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 774, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 774, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b2e653faa3606a908937763db2a58be4e850ca4d76b732aafb6b5d7f6fb43eb5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: info-exp-prop-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: missing property name for block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 877, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 877, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f36b0edfe97fc0457306aa14dbb007967363db6e263b4e77759aecf3d247cbe0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: info-exp-prop-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: missing property name for block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 877, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 877, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bc355ffe3cb6c6fe59f2ffd6ffdd4e940842a7f85668589171a50bd2dfcd8b44", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: info-exp-prop-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'get-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 774, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 774, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6c281ada35dd5f4106245c510b47c1586ac23cff858e2e35d565de69cd00e34f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: info-exp-prop-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: use of unresolved function \'get-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 774, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 774, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_burn_block_info_expect_property_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_burn_block_info_expect_property_name.snap new file mode 100644 index 00000000000..6086a6a7b01 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_burn_block_info_expect_property_name.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "be66b157914db38bb7d0d83d6a5bcc53112f576a3a56d63433e70ed3e7d15df3", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: burn-exp-prop-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-burn-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 909, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 909, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "285fea62d6e68041920eb611ed9e9b00bce0d23de952bdbd779ad8ef3edd52f5", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: burn-exp-prop-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: missing property name for burn block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1012, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1012, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9bcfb142b2ad40ddb1fe3c09ff1d12c4a782456493d36f4b27a7b28506f54fff", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: burn-exp-prop-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: missing property name for burn block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1012, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1012, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "aa1fd68469a1282bff26443e7a27820bbeae8be94e1b2ae94ece5ba5a0294531", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: burn-exp-prop-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-burn-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 909, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 909, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3b769e338330a28330a65296c04b58f04b976da7deef1b7dc09fe6b2c54ffbc2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: burn-exp-prop-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: missing property name for burn block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1012, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1012, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "357e3eeda4016ac008e0b296479d6f6bc5ca423e09968e35b5c489272f1c5c60", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: burn-exp-prop-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: missing property name for burn block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1012, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1012, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3a859965ee74caab40b41d1c33de5c204d57228f6de8a3ef6ff8f739c0b48d69", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: burn-exp-prop-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: missing property name for burn block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1012, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1012, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_stacks_block_info_expect_property_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_stacks_block_info_expect_property_name.snap new file mode 100644 index 00000000000..595806ca334 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_stacks_block_info_expect_property_name.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "f4f61c95b8100ce2ccc709a481727b002fac137e607966ebd4b4024b5f60e552", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: stacks-exp-prop-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-stacks-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ec500c8a69f9b22bb3a846f3f6409ec44dadb016772762b85d25c5c2a9f9329b", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: stacks-exp-prop-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'get-stacks-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3fe13890525320eb44077af280329aae270358eb3236b5171f8240dfccd2d3c8", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: stacks-exp-prop-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: missing property name for stacks block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d68e6d77c52bee7b2d7ddb4943c1e68ce493610d434fa544ec10d5163dbf86ea", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: stacks-exp-prop-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-stacks-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3bb4bc8f3e4d7a6ce85a523ea6714bc5333773bd68a633a3867ea052e759801b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: stacks-exp-prop-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'get-stacks-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 963, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c08b1361f2c4789c0ae51f1247cec9493b2a8aefa4844ffeda82afd8b84290cc", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: stacks-exp-prop-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: missing property name for stacks block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b185301a9838616acbff7c205f352cc826c21c4300708aedea7d5293213bbd02", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: stacks-exp-prop-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: missing property name for stacks block info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1066, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_tenure_info_expect_property_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_tenure_info_expect_property_name.snap new file mode 100644 index 00000000000..d7ba33befbb --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_get_tenure_info_expect_property_name.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "503019f3be7848862c59c2c95182cf38f978d976e72025075e64bab14cb2af93", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: tenure-exp-prop-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-tenure-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "10e364f0c21497667a034bd319a4e8d5f832a926842af30df0e8028e2d22a18a", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: tenure-exp-prop-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'get-tenure-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fae7a27bd434f4bed8441850e0d020caba41420c0b92d3d06f88841a6f5c62d5", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: tenure-exp-prop-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: missing property name for tenure info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 904, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 904, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "00fef77c7c9765b83b866477b30dbce807ab2291a00a009bf0e944f0c930b58e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: tenure-exp-prop-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-tenure-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6dfbbb26b1c51bd41cfe2de1844fc14c4bca430f63a52fd56822bb37597600f1", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: tenure-exp-prop-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'get-tenure-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 801, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b3983acee10d69ad095ff482be5eec8c6ca27be4fd258985777cd8744e8601c3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: tenure-exp-prop-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: missing property name for tenure info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 904, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 904, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "df82d3c8b59854d4be74637ef28c259a477c5717566d89f5cff02fdb3fe5b893", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: tenure-exp-prop-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: missing property name for tenure info introspection) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 904, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 904, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_max_identifier_length_exceeded.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_max_identifier_length_exceeded.snap new file mode 100644 index 00000000000..56c73249982 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_max_identifier_length_exceeded.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "f2f3ba173a90922bb0d11f3ce325b68989032b6c09df3f60ce1500054c859009", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: max-ident-len-excd-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "01f34ec01ee3b6548d41171f59fcdc52af35ad8659e85aa244ee2bf14eaab810", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: max-ident-len-excd-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8ea9dd51252de119f5aad278dbaa8a243c6c11ce42c9956b54c8b175a1ce4fd9", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: max-ident-len-excd-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3de1f17a276691921edab420e8c9d2e0abe26bb053bc7caee8c70ae5e52308b3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: max-ident-len-excd-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "389dbd18c3ebd7e96bde7ffdb1bd5effb0c3b40b14f330021385dc882d9035c0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: max-ident-len-excd-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8d021f0116ae74773cb28299fa0d187047187d01a687bdfd612abaaf3b96554c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: max-ident-len-excd-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 12654, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a8a43db9c0970bb8cb292cf28e5271a949860c0091e05f3189a9daa0cb2e205c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: max-ident-len-excd-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: with-nft allowance identifiers list must not exceed 128 elements, got 130) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 142, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 16108, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 142, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 16108, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_map.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_map.snap new file mode 100644 index 00000000000..55dbd73ad48 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_map.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "f96b95048904ee4a145d4bf749023b49ed964f22b2eafd5b273226005e78c861", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-map-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved map \'non-existent\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fb508ff956f1793537ddf093406d28a54e0e4850d046e221fa26589170895c61", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-map-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved map \'non-existent\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d60b09b5bc98b4d1e9946c3c28642b2d9c28f8dd5caf388ac20e67ca20e4fbe1", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-map-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved map \'non-existent\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f5a73a40fabc82763e791a92aebb78c5f6351b28459e33a783b31dac294432f3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-map-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved map \'non-existent\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5c50a61f1844d021bdd81c16df301537b38f8af7115eabe561bc140b596a185b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-map-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved map \'non-existent\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0bf931736dbeb7de70be8db6d4b9b4890ee2c48ced58e804b3058522bc15ea5c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-map-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved map \'non-existent\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2c7a39cc2e608979c5fc15bea2e314a3ad8cef29ead3ea41050b566986e4d7da", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-map-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: use of unresolved map \'non-existent\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1406, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_stacks_block_info_property.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_stacks_block_info_property.snap new file mode 100644 index 00000000000..cbf7a9c069b --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_stacks_block_info_property.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "d5b59f773e6001ae66d3f157abc1a9dc17dbd4c8648c1aa4eb83fb8840104c7c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-stacks-info-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-stacks-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1017, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1017, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2a7abc5ce163978df83dc6523b0f24afe2a6fa720a0fd156fdf0ee556481cfa5", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-stacks-info-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'get-stacks-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1017, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1017, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1a1cef94d933f5885b459948a0366c49a34d33ba79445213dfe6c6d06b9bc83a", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-stacks-info-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unknown stacks block property \'none\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ac31a4c73339adc5ee08fe4b650fd255341268382d3f1852b9906da7649f1704", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-stacks-info-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-stacks-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1017, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1017, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c905cb7f6e6f693c24f4994857d74e02fe792f76fc3fb79c6acd5f4838aadc52", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-stacks-info-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'get-stacks-block-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1017, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1017, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b3b40a582a7ffbd7b000aadf42047646795b55681a5c94eda4707cb1dd680e9d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-stacks-info-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unknown stacks block property \'none\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0a86556ee0cefd34a1df9f5a7ba9485f7751f3d62ae4874c9a6aba71b9cfba00", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-stacks-info-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: use of unknown stacks block property \'none\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1120, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_tenure_info_property.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_tenure_info_property.snap new file mode 100644 index 00000000000..1a3db7bd42c --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_tenure_info_property.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "07d3482d05c9e007a56de1f56f5d5b267aed1428c618b68c144d1eb6b11c50aa", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tenure-info-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-tenure-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 855, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 855, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b4632aafe7321437c72070c86510cd0d82543c2fcb9152bd8474006d812ad957", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tenure-info-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'get-tenure-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 855, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 855, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6ba12229805648cf6da579dca26ef85bf7cba8fd1a7c03fb4b5538c4fc746bb3", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tenure-info-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unknown tenure property \'none\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 958, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 958, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "87dfa6c151c1049f3888b51186d7420fe7d562f6946a77bd99ad3921e4b77a02", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tenure-info-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'get-tenure-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 855, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 855, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "14028138a99ce295c042adac177ebcbc677a6718e03f4c25caf850837dc3a42b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tenure-info-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'get-tenure-info?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 855, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 855, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a099b047d232d4d37ae2601aa87b7b052df2270b9e5e913a201ffe6904101fd5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tenure-info-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unknown tenure property \'none\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 958, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 958, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0057a5aba7e3bd21b2beb7649b92731b43b8d5d6271d7e60d305bddecc595da6", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tenure-info-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: use of unknown tenure property \'none\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 958, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 958, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_tuple_field.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_tuple_field.snap new file mode 100644 index 00000000000..cca9199ff66 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_tuple_field.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "be66b157914db38bb7d0d83d6a5bcc53112f576a3a56d63433e70ed3e7d15df3", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tuple-f-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: cannot find field \'value\' in tuple \'(tuple (name int))\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1e613ae1a3cbd05c335f9d4041e26cc9446ae100ee5641e577975be484e17d81", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tuple-f-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: cannot find field \'value\' in tuple \'(tuple (name int))\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "371f1a124e820f053d8f15116cdb01d8363fba853425147d8308b9234cf10dd4", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tuple-f-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: cannot find field \'value\' in tuple \'(tuple (name int))\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8ed8d147cde3182b98124f56c57e1a1f9aa609337490a32723fe6372088b64db", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tuple-f-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: cannot find field \'value\' in tuple \'(tuple (name int))\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fb90fb5fa51223d9d0e2201d4fc7d8e9ddb1b90995cad7f2de588be7f0d323d4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tuple-f-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: cannot find field \'value\' in tuple \'(tuple (name int))\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ac5cb2a4763f35a022eeaeed799fa5405aeb2f967da8f531ca544f03f0a40f55", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tuple-f-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: cannot find field \'value\' in tuple \'(tuple (name int))\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "26ddb2f3addeb42c014ce088807b574a969fd9335d490576353c1f567893ac01", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-tuple-f-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: cannot find field \'value\' in tuple \'(tuple (name int))\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1084, + ), + )), +] From c1ee26a9fe9d6cb69b9682beb28c87fe2c98d2f1 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Mon, 10 Nov 2025 12:01:47 +0000 Subject: [PATCH 09/40] add fifth set of StaticCheckError consensus tests --- stackslib/src/chainstate/tests/consensus.rs | 106 ++++++++- ...heck_error_allowance_expr_not_allowed.snap | 216 ++++++++++++++++++ ...or_at_block_closure_must_be_read_only.snap | 216 ++++++++++++++++++ ...check_error_contract_of_expects_trait.snap | 216 ++++++++++++++++++ ...c_check_error_expected_allowance_expr.snap | 216 ++++++++++++++++++ ...ic_check_error_expected_callable_type.snap | 216 ++++++++++++++++++ ...eck_error_expected_list_of_allowances.snap | 216 ++++++++++++++++++ ...c_check_error_no_such_public_function.snap | 216 ++++++++++++++++++ ...with_nft_expected_list_of_identifiers.snap | 216 ++++++++++++++++++ 9 files changed, 1826 insertions(+), 8 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_allowance_expr_not_allowed.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_at_block_closure_must_be_read_only.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_contract_of_expects_trait.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_allowance_expr.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_callable_type.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_list_of_allowances.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_public_function.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_nft_expected_list_of_identifiers.snap diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index 5730c4c4906..85369800507 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -51,6 +51,7 @@ use crate::core::test_util::{ }; use crate::core::{EpochList, BLOCK_LIMIT_MAINNET_21}; use crate::net::tests::NakamotoBootPlan; +use crate::util_lib::boot::boot_code_test_addr; /// The epochs to test for consensus are the current and upcoming epochs. /// This constant must be changed when new epochs are introduced. @@ -1582,6 +1583,29 @@ contract_deploy_consensus_test!( contract_code: "(contract-call? 'S1G2081040G2081040G2081040G208105NK8PE5.contract-name u1)", ); +// StaticCheckError: [`StaticCheckErrorKind::ExpectedCallableType`] +// Caused by: passing a non-callable constant as the contract principal in `contract-call?`. +// Outcome: block accepted. +// Note: This error was added in Clarity 2. Clarity 1 will trigger a [`StaticCheckErrorKind::TraitReferenceUnknown`]. +contract_deploy_consensus_test!( + static_check_error_expected_callable_type, + contract_name: "exp-callable-type", + contract_code: " + (define-constant bad-contract u1) + (contract-call? bad-contract call-me) + ", +); + +// StaticCheckError: [`StaticCheckErrorKind::NoSuchPublicFunction`] +// Caused by: calling a non-existent public or read-only function on a contract literal. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_no_such_public_function, + contract_name: "no-such-pub-func-lit", + // using the pox-4 contract as we know it exists! + contract_code: &format!("(contract-call? '{}.pox-4 missing-func)", boot_code_test_addr()), +); + // StaticCheckError: [`StaticCheckErrorKind::DefaultTypesMustMatch`] // Caused by: // Outcome: block accepted. @@ -1759,6 +1783,15 @@ contract_deploy_consensus_test!( contract_code: "(+ 1 )", ); +// StaticCheckError: [`StaticCheckErrorKind::ContractOfExpectsTrait`] +// Caused by: calling `contract-of` with a non-trait argument. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_contract_of_expects_trait, + contract_name: "expect-trait", + contract_code: "(contract-of u1)", +); + // StaticCheckError: [`StaticCheckErrorKind::TraitMethodUnknown`] // Caused by: // Outcome: block accepted. @@ -1784,6 +1817,52 @@ contract_deploy_consensus_test!( (silly)", ); +// StaticCheckError: [`StaticCheckErrorKind::AtBlockClosureMustBeReadOnly`] +// Caused by: `at-block` closure must be read-only but contains write operations. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_at_block_closure_must_be_read_only, + contract_name: "closure-must-be-ro", + contract_code: " + (define-data-var foo int 1) + (define-private (foo-bar) + (at-block (sha256 0) + (var-set foo 0)))", +); + +// StaticCheckError: [`StaticCheckErrorKind::AllowanceExprNotAllowed`] +// Caused by: using an allowance expression outside of `restrict-assets?` or `as-contract?`. +// Outcome: block accepted. +// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_allowance_expr_not_allowed, + contract_name: "allow-expr-not-allo", + contract_code: "(with-stx u1)", +); + +// StaticCheckError: [`StaticCheckErrorKind::ExpectedListOfAllowances`] +// Caused by: post-condition expects a list of asset allowances but received invalid input. +// Outcome: block accepted. +// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_expected_list_of_allowances, + contract_name: "exp-list-of-allowances", + contract_code: "(restrict-assets? tx-sender u1 true)", +); + +// StaticCheckError: [`StaticCheckErrorKind::ExpectedAllowanceExpr`] +// Caused by: allowance list contains a non-allowance expression. +// Outcome: block accepted. +// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_expected_allowance_expr, + contract_name: "exp-allowa-expr", + contract_code: "(restrict-assets? tx-sender ((not true)) true)", +); + // StaticCheckError: [`StaticCheckErrorKind::WithAllAllowanceNotAllowed`] // Caused by: // Outcome: block accepted. @@ -1806,6 +1885,17 @@ contract_deploy_consensus_test!( contract_code: "(as-contract? ((with-all-assets-unsafe) (with-stx u1000)) true)", ); +// StaticCheckError: [`StaticCheckErrorKind::WithNftExpectedListOfIdentifiers`] +// Caused by: the third argument to `with-nft` is not a list of identifiers. +// Outcome: block accepted. +// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +contract_deploy_consensus_test!( + static_check_error_with_nft_expected_list_of_identifiers, + contract_name: "with-nft-exp-ident", + contract_code: r#"(restrict-assets? tx-sender ((with-nft tx-sender "token-name" tx-sender)) true)"#, +); + // StaticCheckError: [`StaticCheckErrorKind::MaxIdentifierLengthExceeded`] // Caused by: // Outcome: block accepted. @@ -2004,10 +2094,10 @@ contract_deploy_consensus_test!( // DefineVariableBadSignature, [`static_check_error_define_variable_bad_signature`] // ReturnTypesMustMatch(Box, Box), [`static_check_error_return_types_must_match`] // NoSuchContract(String), [`static_check_error_no_such_contract`] -// NoSuchPublicFunction(String, String), +// NoSuchPublicFunction(String, String), [`static_check_error_no_such_public_function`] // ContractAlreadyExists(String), // ContractCallExpectName, [`static_check_error_contract_call_expect_name`] -// ExpectedCallableType(Box), +// ExpectedCallableType(Box), [`static_check_error_expected_callable_type`] // NoSuchBlockInfoProperty(String), [`static_check_error_no_such_block_info_property`] // NoSuchStacksBlockInfoProperty(String), [`static_check_error_no_such_stacks_block_info_property`] // NoSuchTenureInfoProperty(String), [`static_check_error_no_such_tenure_info_property`] @@ -2041,16 +2131,16 @@ contract_deploy_consensus_test!( // DefineTraitBadSignature, [`static_check_error_define_trait_bad_signature`] // DefineTraitDuplicateMethod(String), [`static_check_error_define_trait_duplicate_method`] // UnexpectedTraitOrFieldReference, [`static_check_error_unexpected_trait_or_field_reference`] -// ContractOfExpectsTrait, +// ContractOfExpectsTrait, [`static_check_error_contract_of_expects_trait`] // IncompatibleTrait(Box, Box), [`static_check_error_incompatible_trait`] // WriteAttemptedInReadOnly, [`static_check_error_write_attempted_in_read_only`] -// AtBlockClosureMustBeReadOnly, -// ExpectedListOfAllowances(String, i32), -// AllowanceExprNotAllowed, -// ExpectedAllowanceExpr(String), +// AtBlockClosureMustBeReadOnly, [`static_check_error_at_block_closure_must_be_read_only`] +// ExpectedListOfAllowances(String, i32), [`static_check_error_expected_list_of_allowances`] +// AllowanceExprNotAllowed, [`static_check_error_allowance_expr_not_allowed`] +// ExpectedAllowanceExpr(String), [`static_check_error_expected_allowance_expr`] // WithAllAllowanceNotAllowed, [`static_check_error_with_all_allowance_not_allowed`] // WithAllAllowanceNotAlone, [`static_check_error_with_all_allowance_not_alone`] -// WithNftExpectedListOfIdentifiers, +// WithNftExpectedListOfIdentifiers, [`static_check_error_with_nft_expected_list_of_identifiers`] // MaxIdentifierLengthExceeded(u32, u32), [`static_check_error_max_identifier_length_exceeded`] // TooManyAllowances(usize, usize), [`static_check_error_too_many_allowances`] // } diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_allowance_expr_not_allowed.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_allowance_expr_not_allowed.snap new file mode 100644 index 00000000000..f8e82b2bc91 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_allowance_expr_not_allowed.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "bba0008d47ee775134987e1d07b44fb1ee3f4aaa697cf942cfd5f41672596e44", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: allow-expr-not-allo-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'with-stx\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "17d56c4112311bf8f7b40c835f2e806a713d7449173e8b13771de124d18f4de2", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: allow-expr-not-allo-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'with-stx\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ba7665b0d3ec67a503646d0665b7fb1c6406bc8137168668fd6302047c84c4e2", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: allow-expr-not-allo-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'with-stx\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b0e4d1252ca86bcdbf45080975eae79736cee7ee9109363395839695af22f990", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: allow-expr-not-allo-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'with-stx\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a9765ffc7fa56d733662082c7338b02f7440a8e0995359b2dff94ca2fbd8fdc0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: allow-expr-not-allo-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'with-stx\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c1b2ac8f5abc067a85ae68793c0eaf6c9c9a115241d6cc0c9922ee1e2d7089f3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: allow-expr-not-allo-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'with-stx\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 504, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9bc7d1d78762c0692367573435d32788c45f382de2af6293cffb198a0c0b7d92", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: allow-expr-not-allo-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: allowance expressions are only allowed in the context of a `restrict-assets?` or `as-contract?`) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 605, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_at_block_closure_must_be_read_only.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_at_block_closure_must_be_read_only.snap new file mode 100644 index 00000000000..39b0bdb98c0 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_at_block_closure_must_be_read_only.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "32ed629cb03b316d5a76c722a3c5273d3b86e929c506db682adec1877a84ba90", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: closure-must-be-ro-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: (at-block ...) closures expect read-only statements, but detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "54c1de316ab985d4d72d5ba7891a950de003b1acc33781bb915e2e236a75d6b0", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: closure-must-be-ro-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: (at-block ...) closures expect read-only statements, but detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7982dcff5c02e711c8db5c053290721f82e2cde4f997a8406c62d90dc49ebf3f", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: closure-must-be-ro-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: (at-block ...) closures expect read-only statements, but detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3c8aa3e963692f0aacc2ff8a3e457763b95080989ac41203398f59c343bc89d8", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: closure-must-be-ro-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: (at-block ...) closures expect read-only statements, but detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6887c3c354f3ef797f20a5753e496f5165406aa2ca0c5a78e0d74a41c1359cb7", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: closure-must-be-ro-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: (at-block ...) closures expect read-only statements, but detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f9a8942a4937c69623a65b1229fba8b65e8dace4274e38c15924923994aeaf7b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: closure-must-be-ro-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: (at-block ...) closures expect read-only statements, but detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "045b7c03376f9e568ab2b1b1c08d4e0829eab0e74fe4afdbccd3c04a7d8ed61a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: closure-must-be-ro-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: (at-block ...) closures expect read-only statements, but detected a writing operation) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 3966, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_contract_of_expects_trait.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_contract_of_expects_trait.snap new file mode 100644 index 00000000000..0d8623258ab --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_contract_of_expects_trait.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5ba074a74da014e52ff1a01d1058774e6968b715ae3c20db1c2eaf82b5f098d6", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expect-trait-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: trait reference expected) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6cc731445c9251f8085915f6e653fa47f4b8fae4b5ce91b23ecd994cfb58a7aa", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expect-trait-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: trait reference expected) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2c2dfbfd42772b4269ca1073b3af4d513855f92c6c6fec429781f4bd047dba3c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expect-trait-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: trait reference expected) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "50616bb7bf4f0a53a49405cc3d942ac5a2ffbf5e4fe4864e35a79c664981d6f9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expect-trait-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: trait reference expected) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f9f656db6aaf3392054c333979c64532cdcb008f734d445cad12e6fb7380b346", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expect-trait-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: trait reference expected) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "429ed83e52f40a41651b7a5eadca166dcc999040d0edd1b40c581b5f213b9208", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expect-trait-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: trait reference expected) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "267230fa0cd5148048cb46f79dc386bdeafb0dcccbdcd0a295639ea1dcea7ad2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: expect-trait-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: trait reference expected) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 4, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 686, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_allowance_expr.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_allowance_expr.snap new file mode 100644 index 00000000000..5ffc2d35289 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_allowance_expr.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "9d578659db0d60582e0d0c2350b397495bc82815f341e1325694a87eefbc93e7", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-allowa-expr-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d87a0d1ce3729612d891cb1be806ae27cacb9364b4956d0e5d73822ca9a5a564", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-allowa-expr-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6ca5b1afed24ead11ae24bd2326588f8ea2af0cb43cb2aa81303e4c00a39e61e", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-allowa-expr-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e078946ba78d53ad2ba58a368bedf00034def8ca8700b475bf1f3cbff70e854a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-allowa-expr-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "821cf83929195cae5b846054b4f9e159ccf1dcf155e7a0589ebdc61f4cdcb12c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-allowa-expr-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9b27e242fcdbe940308d9989be0f83427bac5789bdb4b3176a0c8ac1acf80748", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-allowa-expr-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1395, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ac6e6ae2480e606a1223a7105a473de8ca914ac43a2c0889532106459beadbdd", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-allowa-expr-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expected an allowance expression, got: not) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1653, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1653, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_callable_type.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_callable_type.snap new file mode 100644 index 00000000000..7048b0b91d9 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_callable_type.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "1f2fc1b89c6f89df000b1f3910330db5be3c35df72ad37dc074bff28a0a90ab3", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-callable-type-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of undeclared trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d506c60983ed1f3965194737a0b65fbcb51c23c85983da9514f85bccf0b8ad29", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-callable-type-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expected a callable contract, found uint) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0dfaa59369e452c4fe6048a47e3d06bf2f0c0f309db5de0a4ec3190a812f59c9", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-callable-type-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expected a callable contract, found uint) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f51df90e6e1b4afcd20d724688df376cc921acbc41051cbfab5b9ddfd7f9b798", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-callable-type-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of undeclared trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b8ba0e5cf85c0b02c45180c18dcdfb5ef1fcb06e8063981880505121d169f7f3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-callable-type-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: expected a callable contract, found uint) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5b689e2a1addd379c1ff5c972cfa3ebd85c4c37053ab27e8056ae74b92c96aa5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-callable-type-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: expected a callable contract, found uint) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6ed5b3c85b10639b11c2565d4e1764a5d3d60b535077cbee6c8ffac6414d09d1", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-callable-type-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: expected a callable contract, found uint) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 9, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2846, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_list_of_allowances.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_list_of_allowances.snap new file mode 100644 index 00000000000..f76cb005a07 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_expected_list_of_allowances.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "34b362f8dadde6564274df15d3dfbeece020b820eaaf9eb7c7e6a1208f049522", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-list-of-allowances-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "14b0072b0684eb00b147298881cfdc8d3994f4f7be67673f4adea93b3c1b9a67", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-list-of-allowances-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "255a56a7c66954ed3cbcdb2a3d2c7447c9f27e76418f66371c1282206d743732", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-list-of-allowances-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8239b17e593b8375e932154ae2af349918df878a2e303a05b70bc4abe5094bf2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-list-of-allowances-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "660bbc5d01cc1448bdcbe7a64404a8eb1eec7cb7edfcbbf06e7a37ce01662eee", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-list-of-allowances-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c8563b01965534e8f8b2701703b4ca3183260eb056ade4e94a85f312d5854503", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-list-of-allowances-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "71427ec868a0aaffba8b23455f7cadbf7f291070fda593cbc45625f235b441bd", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: exp-list-of-allowances-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: restrict-assets? expects a list of asset allowances as argument 2) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 1125, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_public_function.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_public_function.snap new file mode 100644 index 00000000000..ffe122356e7 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_no_such_public_function.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "bac3f91272f70bddd13b04c59ae408ef7c070bc6348f41e60bb7730dae8d8ea5", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-pub-func-lit-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: contract \'ST000000000000000000002AMW42H.pox-4\' has no public function \'missing-func\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c0498cec8b2b231780caebc226efeae9b910f474f66399d24000c58d912ce482", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-pub-func-lit-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: contract \'ST000000000000000000002AMW42H.pox-4\' has no public function \'missing-func\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8360d50b3dc2dfc80e0f7b220d425b229de645151dfe8338b8d2252d45a2873a", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-pub-func-lit-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: contract \'ST000000000000000000002AMW42H.pox-4\' has no public function \'missing-func\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b124f452c51944c27b656d2d626d897bb3a81c08a19f2eee94758da2ec301353", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-pub-func-lit-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: contract \'ST000000000000000000002AMW42H.pox-4\' has no public function \'missing-func\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fe347fdda3efa8afcc3be690b84d36aaad64fc4e7f94b3fcdffc0b62d9318a43", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-pub-func-lit-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: contract \'ST000000000000000000002AMW42H.pox-4\' has no public function \'missing-func\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ef057333b6178917755c1aa23f3052a8e3b8b72e1d564a32018729977801c098", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-pub-func-lit-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: contract \'ST000000000000000000002AMW42H.pox-4\' has no public function \'missing-func\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "52b25e2aaf0f511e1251c27dc3d83744a2ce4189fb66c67cdc1841d36b60ceeb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: no-such-pub-func-lit-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: contract \'ST000000000000000000002AMW42H.pox-4\' has no public function \'missing-func\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 5, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2038, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_nft_expected_list_of_identifiers.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_nft_expected_list_of_identifiers.snap new file mode 100644 index 00000000000..44a412bcd76 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_with_nft_expected_list_of_identifiers.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "bcccc5b765cdc772cc53f74e7cbfbe72f47d5e63de644373bf30c090c503074c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: with-nft-exp-ident-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "31078e333f3f2acd6168a966cf466ba4a31ed4c2d865a4bf619f17b451b27187", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: with-nft-exp-ident-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c36ab39a1222c03a65fd19994805bceb1eb0805b69c11847b9b7cf02cf7c5d45", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: with-nft-exp-ident-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5f526f3150ce46ac02ad5b7ce17487b67862a48bcf747c80d977f9c0b48a7374", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: with-nft-exp-ident-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "61ce3f27d97820ef61aca24edbe0086d6b1fd39a06ce9e4bcee91e187891a2e1", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: with-nft-exp-ident-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bd8bcf9b7bb55852b37b9e6fea33d99b103f2eac79531358d3aa6a7a458f571a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: with-nft-exp-ident-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: use of unresolved function \'restrict-assets?\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 2286, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a61e73fd2d73752e4e9a7ea01c04ca28d6fbb88c20d6f32ce30d9bdac4a82693", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: with-nft-exp-ident-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: with-nft allowance must include a list of asset identifiers) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3293, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 11, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3293, + ), + )), +] From 47cd8b947831ddbbe305d0f68a40811ccbc751f2 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Mon, 10 Nov 2025 18:06:05 +0000 Subject: [PATCH 10/40] add static_check_error_cost_balance_exceeded --- stackslib/src/chainstate/tests/consensus.rs | 28 +++++++++++++++++-- ...tic_check_error_cost_balance_exceeded.snap | 13 +++++++++ 2 files changed, 39 insertions(+), 2 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_cost_balance_exceeded.snap diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index 85369800507..42b9b425597 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -1171,6 +1171,30 @@ contract_deploy_consensus_test!( }, ); +// StaticCheckError: [`StaticCheckErrorKind::CostBalanceExceeded`] +// Caused by: exceeding the static-read analysis budget during contract deployment. +// The contract repeatedly performs static-dispatch `contract-call?` lookups against the boot +// `.costs-3` contract, forcing the type checker to fetch the remote function signature enough +// times to surpass the read-count limit in `BLOCK_LIMIT_MAINNET_21`. +// Outcome: block rejected. +contract_deploy_consensus_test!( + static_check_error_cost_balance_exceeded, + contract_name: "cost-balance-exceeded", + contract_code: &{ + let boot_addr = boot_code_test_addr(); + let mut contract = String::from("(define-read-only (trigger)\n (begin\n"); + let call_count = BLOCK_LIMIT_MAINNET_21.read_count as usize + 1; + let call_line = format!( + "(contract-call? '{boot_addr}.costs-3 cost_analysis_type_check u0)\n", + ); + for _ in 0..call_count { + contract.push_str(&call_line); + } + contract.push_str("true))"); + contract + }, +); + // StaticCheckError: [`StaticCheckError::ValueTooLarge`] // Caused by: Value exceeds the maximum allowed size for type-checking // Outcome: block accepted. @@ -2045,8 +2069,8 @@ contract_deploy_consensus_test!( ); // pub enum StaticCheckErrorKind { -// CostOverflow, -// CostBalanceExceeded(ExecutionCost, ExecutionCost), +// CostOverflow, // Unreachable: should exceed u64 +// CostBalanceExceeded(ExecutionCost, ExecutionCost), [`static_check_error_cost_balance_exceeded`] // MemoryBalanceExceeded(u64, u64), // CostComputationFailed(String), // ExecutionTimeExpired, diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_cost_balance_exceeded.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_cost_balance_exceeded.snap new file mode 100644 index 00000000000..c573e16d8f8 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_cost_balance_exceeded.snap @@ -0,0 +1,13 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Failure("Invalid Stacks block 78d46d825b17b2560c0fff257020dd03000a76e2bc73ca715c9f8445390a9bfc: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135183501 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block ba01738f82cd9fe4308e3c35fe1160f943177a0e09fcee47eb4a6aee75a249bc: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135168502 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block b5dfc634bd5a95eee562f49520a44646b0bb34a77e4fef17d80bc3919f69a597: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135168502 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block 5ea5795cdfe591f13d86a8ad14cf4bb2ec6ff8cf32a170239937bc4c84f2d0a4: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135183501 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block cf6464afc1ca5c82d1ba78f1b8189b7dcd146df01d8ed7481bdfcfedb0e7b478: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135168502 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block 905816b6fbb8b5065cdd413e6013a056b116046f86ae0e28d6fcbe937790c956: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135168502 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block da236547c04330b4f30308091af8580491bd81de0c35ac53106924dcba8a4555: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135168502 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), +] From e8e45d8aa05b12a6955a3f3300ec7271d6436d58 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Mon, 10 Nov 2025 18:09:17 +0000 Subject: [PATCH 11/40] fix StaticCheckError conversion in smart_contract_analysis --- clarity/src/vm/clarity.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clarity/src/vm/clarity.rs b/clarity/src/vm/clarity.rs index bd06b628c46..4e34885cf4e 100644 --- a/clarity/src/vm/clarity.rs +++ b/clarity/src/vm/clarity.rs @@ -258,7 +258,7 @@ pub trait TransactionConnection: ClarityConnection { let cost_track = contract_analysis.take_contract_cost_tracker(); (cost_track, Ok((contract_ast, contract_analysis))) } - Err(e) => (e.1, Err(ClarityError::StaticCheck(e.0))), + Err(e) => (e.1, Err(e.0.into())), } }) } From f74eceead27882b00b327303ab575e7109ff382a Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Tue, 11 Nov 2025 18:20:51 +0000 Subject: [PATCH 12/40] add new tests --- stackslib/src/chainstate/tests/consensus.rs | 350 +++++++++++++----- ...us__check_error_cost_balance_exceeded.snap | 13 + ...stacks_transaction_duplicate_contract.snap | 41 ++ ..._check_error_bad_trait_implementation.snap | 244 ++++++++++++ 4 files changed, 548 insertions(+), 100 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_cost_balance_exceeded.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__error_invalid_stacks_transaction_duplicate_contract.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_trait_implementation.snap diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index 42b9b425597..26d6d57e92e 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -425,7 +425,7 @@ impl TestTxFactory { TestTxSpec::ContractDeploy { sender, .. } => sender, TestTxSpec::ContractCall { sender, .. } => sender, }; - let address = StacksAddress::p2pkh(false, &StacksPublicKey::from_private(sender_privk)); + let address = to_addr(sender_privk); let nonce = self .nonce_counter .get_mut(&address) @@ -1171,12 +1171,13 @@ contract_deploy_consensus_test!( }, ); -// StaticCheckError: [`StaticCheckErrorKind::CostBalanceExceeded`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::CostBalanceExceeded`] // Caused by: exceeding the static-read analysis budget during contract deployment. // The contract repeatedly performs static-dispatch `contract-call?` lookups against the boot // `.costs-3` contract, forcing the type checker to fetch the remote function signature enough -// times to surpass the read-count limit in `BLOCK_LIMIT_MAINNET_21`. +// times to surpass the read-count limit in [`BLOCK_LIMIT_MAINNET_21`]. // Outcome: block rejected. +// Note: Takes a couple of minutes to run! contract_deploy_consensus_test!( static_check_error_cost_balance_exceeded, contract_name: "cost-balance-exceeded", @@ -1195,7 +1196,7 @@ contract_deploy_consensus_test!( }, ); -// StaticCheckError: [`StaticCheckError::ValueTooLarge`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ValueTooLarge`] // Caused by: Value exceeds the maximum allowed size for type-checking // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1204,7 +1205,7 @@ contract_deploy_consensus_test!( contract_code: "(as-max-len? 0x01 u1048577)", ); -// StaticCheckError: [`StaticCheckError::ValueOutOfBounds`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ValueOutOfBounds`] // Caused by: Value is outside the acceptable range for its type // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1214,7 +1215,7 @@ contract_deploy_consensus_test!( (func 0x00)", ); -// StaticCheckError: [`StaticCheckError::ExpectedName`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedName`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1223,7 +1224,7 @@ contract_deploy_consensus_test!( contract_code: "(match (some 1) 2 (+ 1 1) (+ 3 4))", ); -// StaticCheckError: [`StaticCheckErrorKind::ExpectedResponseType`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedResponseType`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1232,7 +1233,7 @@ contract_deploy_consensus_test!( contract_code: "(unwrap-err! (some 2) 2)", ); -// StaticCheckError: [`StaticCheckErrorKind::CouldNotDetermineResponseOkType`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineResponseOkType`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1241,7 +1242,7 @@ contract_deploy_consensus_test!( contract_code: "(unwrap! (err 3) 2)", ); -// StaticCheckError: [`StaticCheckErrorKind::CouldNotDetermineResponseErrType`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineResponseErrType`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1250,7 +1251,7 @@ contract_deploy_consensus_test!( contract_code: "(unwrap-err-panic (ok 3))", ); -// StaticCheckError: [`StaticCheckErrorKind::CouldNotDetermineMatchTypes`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineMatchTypes`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1259,7 +1260,7 @@ contract_deploy_consensus_test!( contract_code: "(match none inner-value (/ 1 0) (+ 1 8))", ); -// StaticCheckError: [`StaticCheckErrorKind::MatchArmsMustMatch`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::MatchArmsMustMatch`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1268,7 +1269,7 @@ contract_deploy_consensus_test!( contract_code: "(match (some 1) inner-value (+ 1 inner-value) (> 1 28))", ); -// StaticCheckError: [`StaticCheckErrorKind::BadMatchOptionSyntax`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMatchOptionSyntax`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1277,7 +1278,7 @@ contract_deploy_consensus_test!( contract_code: "(match (some 1) inner-value (+ 1 inner-value))", ); -// StaticCheckError: [`StaticCheckErrorKind::BadMatchResponseSyntax`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMatchResponseSyntax`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1286,7 +1287,7 @@ contract_deploy_consensus_test!( contract_code: "(match (ok 1) inner-value (+ 1 inner-value))", ); -// StaticCheckError: [`StaticCheckErrorKind::RequiresAtLeastArguments`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::RequiresAtLeastArguments`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1295,7 +1296,7 @@ contract_deploy_consensus_test!( contract_code: "(match)", ); -// StaticCheckError: [`StaticCheckErrorKind::RequiresAtMostArguments`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::RequiresAtMostArguments`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1304,7 +1305,7 @@ contract_deploy_consensus_test!( contract_code: r#"(principal-construct? 0x22 0xfa6bf38ed557fe417333710d6033e9419391a320 "foo" "bar")"#, ); -// StaticCheckError: [`StaticCheckErrorKind::BadMatchInput`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMatchInput`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1313,7 +1314,7 @@ contract_deploy_consensus_test!( contract_code: "(match 1 ok-val (/ ok-val 0) err-val (+ err-val 7))", ); -// StaticCheckError: [`StaticCheckErrorKind::ExpectedOptionalType`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedOptionalType`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1322,7 +1323,7 @@ contract_deploy_consensus_test!( contract_code: "(default-to 3 5)", ); -// StaticCheckError: [`StaticCheckErrorKind::NameAlreadyUsed`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::NameAlreadyUsed`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1333,7 +1334,7 @@ contract_deploy_consensus_test!( (define-constant foo 20)", ); -// StaticCheckError: [`StaticCheckErrorKind::ReturnTypesMustMatch`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ReturnTypesMustMatch`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1348,7 +1349,7 @@ contract_deploy_consensus_test!( (err false)))", ); -// StaticCheckError: [`StaticCheckErrorKind::TypeError`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::TypeError`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1357,7 +1358,7 @@ contract_deploy_consensus_test!( contract_code: "(define-data-var cursor int true)", ); -// StaticCheckError: [`StaticCheckErrorKind::DefineVariableBadSignature`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineVariableBadSignature`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1366,7 +1367,7 @@ contract_deploy_consensus_test!( contract_code: "(define-data-var cursor 0x00)", ); -// StaticCheckError: [`StaticCheckErrorKind::InvalidTypeDescription`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::InvalidTypeDescription`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1375,7 +1376,7 @@ contract_deploy_consensus_test!( contract_code: "(define-data-var cursor 0x00 true)", ); -// StaticCheckError: [`StaticCheckErrorKind::TypeSignatureTooDeep`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::TypeSignatureTooDeep`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1396,7 +1397,7 @@ contract_deploy_consensus_test!( }, ); -// StaticCheckError: [`StaticCheckErrorKind::SupertypeTooLarge`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::SupertypeTooLarge`] // Caused by: // Outcome: block rejected. contract_deploy_consensus_test!( @@ -1410,7 +1411,7 @@ contract_deploy_consensus_test!( (ok (append initial (tuple (a (var-get small)) (b (var-get big)))))))", ); -// StaticCheckError: [`StaticCheckErrorKind::ConstructedListTooLarge`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ConstructedListTooLarge`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1425,7 +1426,7 @@ contract_deploy_consensus_test!( )", ); -// StaticCheckError: [`StaticCheckErrorKind::UnknownTypeName`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::UnknownTypeName`] // Caused by: // Outcome: block accepted. // Note: during analysis, this error can only be triggered by `from-consensus-buff?` @@ -1439,7 +1440,7 @@ contract_deploy_consensus_test!( (ok (from-consensus-buff? foo 0x00)))", ); -// StaticCheckError: [`StaticCheckErrorKind::UnionTypeError`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::UnionTypeError`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1448,7 +1449,7 @@ contract_deploy_consensus_test!( contract_code: "(map - (list true false true false))", ); -// StaticCheckError: [`StaticCheckErrorKind::UndefinedVariable`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::UndefinedVariable`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1457,7 +1458,7 @@ contract_deploy_consensus_test!( contract_code: "(+ x y z)", ); -// StaticCheckError: [`StaticCheckErrorKind::BadMapTypeDefinition`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMapTypeDefinition`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1466,7 +1467,7 @@ contract_deploy_consensus_test!( contract_code: "(define-map lists { name: int } contents)", ); -// StaticCheckError: [`StaticCheckErrorKind::CouldNotDetermineType`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineType`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1475,7 +1476,7 @@ contract_deploy_consensus_test!( contract_code: "(index-of (list) none)", ); -// StaticCheckError: [`StaticCheckErrorKind::ExpectedSequence`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedSequence`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1484,7 +1485,7 @@ contract_deploy_consensus_test!( contract_code: r#"(index-of 3 "a")"#, ); -// StaticCheckError: [`StaticCheckErrorKind::CouldNotDetermineSerializationType`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineSerializationType`] // Caused by: // Outcome: block accepted. // Note: during analysis, this error can only be triggered by `from-consensus-buff?` @@ -1500,7 +1501,7 @@ contract_deploy_consensus_test!( (ok (to-consensus-buff? (list first second))))", ); -// StaticCheckError: [`StaticCheckErrorKind::UncheckedIntermediaryResponses`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::UncheckedIntermediaryResponses`] // Caused by: Intermediate `(ok ...)` expressions inside a `begin` block that are not unwrapped. // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1513,7 +1514,7 @@ contract_deploy_consensus_test!( (ok true)))", ); -// StaticCheckError: [`StaticCheckErrorKind::NoSuchFT`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchFT`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1522,7 +1523,7 @@ contract_deploy_consensus_test!( contract_code: "(ft-get-balance stackoos tx-sender)", ); -// StaticCheckError: [`StaticCheckErrorKind::NoSuchNFT`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchNFT`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1531,7 +1532,7 @@ contract_deploy_consensus_test!( contract_code: r#"(nft-get-owner? stackoos "abc")"#, ); -// StaticCheckError: [`StaticCheckErrorKind::DefineNFTBadSignature`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineNFTBadSignature`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1540,7 +1541,7 @@ contract_deploy_consensus_test!( contract_code: "(define-non-fungible-token stackaroos integer)", ); -// StaticCheckError: [`StaticCheckErrorKind::BadTokenName`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTokenName`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1549,7 +1550,7 @@ contract_deploy_consensus_test!( contract_code: "(ft-get-balance u1234 tx-sender)", ); -// StaticCheckError: [`StaticCheckErrorKind::EmptyTuplesNotAllowed`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::EmptyTuplesNotAllowed`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1560,7 +1561,7 @@ contract_deploy_consensus_test!( value)", ); -// StaticCheckError: [`StaticCheckErrorKind::NoSuchDataVariable`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchDataVariable`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1571,7 +1572,7 @@ contract_deploy_consensus_test!( (unwrap! (var-get cursor) 0))", ); -// StaticCheckError: [`StaticCheckErrorKind::NonFunctionApplication`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::NonFunctionApplication`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1580,7 +1581,7 @@ contract_deploy_consensus_test!( contract_code: "((lambda (x y) 1) 2 1)", ); -// StaticCheckError: [`StaticCheckErrorKind::ExpectedListApplication`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedListApplication`] // Caused by: calling append with lhs that is not a list. // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1589,7 +1590,7 @@ contract_deploy_consensus_test!( contract_code: "(append 2 3)", ); -// StaticCheckError: [`StaticCheckErrorKind::NoSuchContract`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchContract`] // Caused by: calling contract-call? with a non-existent contract name. // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1598,7 +1599,7 @@ contract_deploy_consensus_test!( contract_code: "(contract-call? 'S1G2081040G2081040G2081040G208105NK8PE5.contract-name test! u1)", ); -// StaticCheckError: [`StaticCheckErrorKind::ContractCallExpectName`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ContractCallExpectName`] // Caused by: calling contract-call? without a contract function name. // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1607,7 +1608,7 @@ contract_deploy_consensus_test!( contract_code: "(contract-call? 'S1G2081040G2081040G2081040G208105NK8PE5.contract-name u1)", ); -// StaticCheckError: [`StaticCheckErrorKind::ExpectedCallableType`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedCallableType`] // Caused by: passing a non-callable constant as the contract principal in `contract-call?`. // Outcome: block accepted. // Note: This error was added in Clarity 2. Clarity 1 will trigger a [`StaticCheckErrorKind::TraitReferenceUnknown`]. @@ -1620,7 +1621,7 @@ contract_deploy_consensus_test!( ", ); -// StaticCheckError: [`StaticCheckErrorKind::NoSuchPublicFunction`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchPublicFunction`] // Caused by: calling a non-existent public or read-only function on a contract literal. // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1630,7 +1631,7 @@ contract_deploy_consensus_test!( contract_code: &format!("(contract-call? '{}.pox-4 missing-func)", boot_code_test_addr()), ); -// StaticCheckError: [`StaticCheckErrorKind::DefaultTypesMustMatch`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::DefaultTypesMustMatch`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1641,7 +1642,7 @@ contract_deploy_consensus_test!( (default-to false (get balance (map-get? tokens (tuple (id 0)))))", ); -// StaticCheckError: [`StaticCheckErrorKind::IfArmsMustMatch`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::IfArmsMustMatch`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1650,7 +1651,7 @@ contract_deploy_consensus_test!( contract_code: "(if true true 1)", ); -// StaticCheckError: [`StaticCheckErrorKind::IllegalOrUnknownFunctionApplication`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::IllegalOrUnknownFunctionApplication`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1659,7 +1660,7 @@ contract_deploy_consensus_test!( contract_code: "(map if (list 1 2 3 4 5))", ); -// StaticCheckError: [`StaticCheckErrorKind::UnknownFunction`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::UnknownFunction`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1668,7 +1669,7 @@ contract_deploy_consensus_test!( contract_code: "(ynot 1 2)", ); -// StaticCheckError: [`StaticCheckErrorKind::IncorrectArgumentCount`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::IncorrectArgumentCount`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1677,7 +1678,7 @@ contract_deploy_consensus_test!( contract_code: "(len (list 1) (list 1))", ); -// StaticCheckError: [`StaticCheckErrorKind::BadLetSyntax`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadLetSyntax`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1686,7 +1687,7 @@ contract_deploy_consensus_test!( contract_code: "(let 1 2)", ); -// StaticCheckError: [`StaticCheckErrorKind::BadSyntaxBinding`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadSyntaxBinding`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1695,8 +1696,8 @@ contract_deploy_consensus_test!( contract_code: "(let ((1)) (+ 1 2))", ); -// StaticCheckError: [`StaticCheckErrorKind::ExpectedOptionalOrResponseType`] -// Caused by: +// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedOptionalOrResponseType`] +// Caused by: expected an optional or response type, but got a value // Outcome: block accepted. contract_deploy_consensus_test!( static_check_error_expected_optional_or_response_type, @@ -1704,7 +1705,7 @@ contract_deploy_consensus_test!( contract_code: "(try! 3)", ); -// StaticCheckError: [`StaticCheckErrorKind::DefineTraitBadSignature`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineTraitBadSignature`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1713,8 +1714,8 @@ contract_deploy_consensus_test!( contract_code: "(define-trait trait-1 ((get-1 uint uint)))", ); -// StaticCheckError: [`StaticCheckErrorKind::DefineTraitDuplicateMethod`] -// Caused by: +// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineTraitDuplicateMethod`] +// Caused by: trait definition contains duplicate method names // Outcome: block accepted. // Note: This error was added in Clarity 2. Clarity 1 will accept the contract. contract_deploy_consensus_test!( @@ -1727,8 +1728,8 @@ contract_deploy_consensus_test!( ))", ); -// StaticCheckError: [`StaticCheckErrorKind::UnexpectedTraitOrFieldReference`] -// Caused by: +// StaticCheckErrorKind: [`StaticCheckErrorKind::UnexpectedTraitOrFieldReference`] +// Caused by: unexpected use of trait reference or field // Outcome: block accepted. contract_deploy_consensus_test!( static_check_error_unexpected_trait_or_field_reference, @@ -1736,7 +1737,7 @@ contract_deploy_consensus_test!( contract_code: "(+ 1 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR.contract.field)", ); -// StaticCheckError: [`StaticCheckErrorKind::IncompatibleTrait`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::IncompatibleTrait`] // Caused by: pass a trait to a trait parameter which is not compatible. // Outcome: block accepted. // Note: Added in Clarity 2. Clarity 1 will trigger a [`StaticCheckErrorKind::TypeError`]. @@ -1756,8 +1757,8 @@ contract_deploy_consensus_test!( (contract-call? contract get-2 u1))", ); -// StaticCheckError: [`StaticCheckErrorKind::ReservedWord`] -// Caused by: +// StaticCheckErrorKind: [`StaticCheckErrorKind::ReservedWord`] +// Caused by: name is a reserved word // Outcome: block accepted. // Note: This error was added in Clarity 3. Clarity 1 and 2 // will trigger a [`StaticCheckErrorKind::NameAlreadyUsed`]. @@ -1767,8 +1768,8 @@ contract_deploy_consensus_test!( contract_code: "(define-private (block-height) true)", ); -// StaticCheckError: [`StaticCheckErrorKind::NoSuchBlockInfoProperty`] -// Caused by: +// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchBlockInfoProperty`] +// Caused by: referenced an unknown property of a burn block // Outcome: block accepted. contract_deploy_consensus_test!( static_check_error_no_such_block_info_property, @@ -1776,8 +1777,8 @@ contract_deploy_consensus_test!( contract_code: "(get-burn-block-info? none u1)", ); -// StaticCheckError: [`StaticCheckErrorKind::NoSuchStacksBlockInfoProperty`] -// Caused by: +// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchStacksBlockInfoProperty`] +// Caused by: referenced an unknown property of a stacks block // Outcome: block accepted. // Note: This error was added in Clarity 3. Clarity 1, and 2 // will trigger a [`StaticCheckErrorKind::UnknownFunction`]. @@ -1787,8 +1788,8 @@ contract_deploy_consensus_test!( contract_code: "(get-stacks-block-info? none u1)", ); -// StaticCheckError: [`StaticCheckErrorKind::NoSuchTenureInfoProperty`] -// Caused by: +// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchTenureInfoProperty`] +// Caused by: referenced an unknown property of a tenure // Outcome: block accepted. // Note: This error was added in Clarity 3. Clarity 1, and 2 // will trigger a [`StaticCheckErrorKind::UnknownFunction`]. @@ -1798,8 +1799,8 @@ contract_deploy_consensus_test!( contract_code: "(get-tenure-info? none u1)", ); -// StaticCheckError: [`StaticCheckErrorKind::TraitReferenceUnknown`] -// Caused by: +// StaticCheckErrorKind: [`StaticCheckErrorKind::TraitReferenceUnknown`] +// Caused by: referenced trait is unknown // Outcome: block accepted. contract_deploy_consensus_test!( static_check_error_trait_reference_unknown, @@ -1807,7 +1808,7 @@ contract_deploy_consensus_test!( contract_code: "(+ 1 )", ); -// StaticCheckError: [`StaticCheckErrorKind::ContractOfExpectsTrait`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ContractOfExpectsTrait`] // Caused by: calling `contract-of` with a non-trait argument. // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1816,8 +1817,8 @@ contract_deploy_consensus_test!( contract_code: "(contract-of u1)", ); -// StaticCheckError: [`StaticCheckErrorKind::TraitMethodUnknown`] -// Caused by: +// StaticCheckErrorKind: [`StaticCheckErrorKind::TraitMethodUnknown`] +// Caused by: defining a method that is not declared in the trait // Outcome: block accepted. contract_deploy_consensus_test!( static_check_error_trait_method_unknown, @@ -1829,7 +1830,7 @@ contract_deploy_consensus_test!( (contract-call? contract get-2 u0))", ); -// StaticCheckError: [`StaticCheckErrorKind::WriteAttemptedInReadOnly`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::WriteAttemptedInReadOnly`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1841,7 +1842,7 @@ contract_deploy_consensus_test!( (silly)", ); -// StaticCheckError: [`StaticCheckErrorKind::AtBlockClosureMustBeReadOnly`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::AtBlockClosureMustBeReadOnly`] // Caused by: `at-block` closure must be read-only but contains write operations. // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1854,7 +1855,7 @@ contract_deploy_consensus_test!( (var-set foo 0)))", ); -// StaticCheckError: [`StaticCheckErrorKind::AllowanceExprNotAllowed`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::AllowanceExprNotAllowed`] // Caused by: using an allowance expression outside of `restrict-assets?` or `as-contract?`. // Outcome: block accepted. // Note: This error was added in Clarity 4. Clarity 1, 2, and 3 @@ -1865,7 +1866,7 @@ contract_deploy_consensus_test!( contract_code: "(with-stx u1)", ); -// StaticCheckError: [`StaticCheckErrorKind::ExpectedListOfAllowances`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedListOfAllowances`] // Caused by: post-condition expects a list of asset allowances but received invalid input. // Outcome: block accepted. // Note: This error was added in Clarity 4. Clarity 1, 2, and 3 @@ -1876,7 +1877,7 @@ contract_deploy_consensus_test!( contract_code: "(restrict-assets? tx-sender u1 true)", ); -// StaticCheckError: [`StaticCheckErrorKind::ExpectedAllowanceExpr`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedAllowanceExpr`] // Caused by: allowance list contains a non-allowance expression. // Outcome: block accepted. // Note: This error was added in Clarity 4. Clarity 1, 2, and 3 @@ -1887,7 +1888,7 @@ contract_deploy_consensus_test!( contract_code: "(restrict-assets? tx-sender ((not true)) true)", ); -// StaticCheckError: [`StaticCheckErrorKind::WithAllAllowanceNotAllowed`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::WithAllAllowanceNotAllowed`] // Caused by: // Outcome: block accepted. // Note: This error was added in Clarity 4. Clarity 1, 2, and 3 @@ -1898,7 +1899,7 @@ contract_deploy_consensus_test!( contract_code: "(restrict-assets? tx-sender ((with-all-assets-unsafe)) true)", ); -// StaticCheckError: [`StaticCheckErrorKind::WithAllAllowanceNotAlone`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::WithAllAllowanceNotAlone`] // Caused by: // Outcome: block accepted. // Note: This error was added in Clarity 4. Clarity 1, 2, and 3 @@ -1909,7 +1910,7 @@ contract_deploy_consensus_test!( contract_code: "(as-contract? ((with-all-assets-unsafe) (with-stx u1000)) true)", ); -// StaticCheckError: [`StaticCheckErrorKind::WithNftExpectedListOfIdentifiers`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::WithNftExpectedListOfIdentifiers`] // Caused by: the third argument to `with-nft` is not a list of identifiers. // Outcome: block accepted. // Note: This error was added in Clarity 4. Clarity 1, 2, and 3 @@ -1920,7 +1921,7 @@ contract_deploy_consensus_test!( contract_code: r#"(restrict-assets? tx-sender ((with-nft tx-sender "token-name" tx-sender)) true)"#, ); -// StaticCheckError: [`StaticCheckErrorKind::MaxIdentifierLengthExceeded`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::MaxIdentifierLengthExceeded`] // Caused by: // Outcome: block accepted. // Note: This error was added in Clarity 4. Clarity 1, 2, and 3 @@ -1936,7 +1937,7 @@ contract_deploy_consensus_test!( ), ); -// StaticCheckError: [`StaticCheckErrorKind::TooManyAllowances`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::TooManyAllowances`] // Caused by: // Outcome: block accepted. // Note: This error was added in Clarity 4. Clarity 1, 2, and 3 @@ -1952,7 +1953,7 @@ contract_deploy_consensus_test!( ), ); -// StaticCheckError: [`StaticCheckErrorKind::BadTupleConstruction`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTupleConstruction`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1961,7 +1962,7 @@ contract_deploy_consensus_test!( contract_code: "(tuple (name 1) (name 2))", ); -// StaticCheckError: [`StaticCheckErrorKind::ExpectedTuple`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedTuple`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1970,7 +1971,7 @@ contract_deploy_consensus_test!( contract_code: "(get field-0 (some 1))", ); -// StaticCheckError: [`StaticCheckErrorKind::NoSuchTupleField`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchTupleField`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1979,7 +1980,7 @@ contract_deploy_consensus_test!( contract_code: "(get value (tuple (name 1)))", ); -// StaticCheckError: [`StaticCheckErrorKind::NoSuchMap`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchMap`] // Caused by: // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1988,7 +1989,7 @@ contract_deploy_consensus_test!( contract_code: "(map-get? non-existent (tuple (name 1)))", ); -// StaticCheckError: [`StaticCheckErrorKind::BadFunctionName`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadFunctionName`] // Caused by: defining a function whose signature does not start with an atom name. // Outcome: block accepted. contract_deploy_consensus_test!( @@ -1997,7 +1998,7 @@ contract_deploy_consensus_test!( contract_code: "(define-private (u1) u0)", ); -// StaticCheckError: [`StaticCheckErrorKind::DefineFunctionBadSignature`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineFunctionBadSignature`] // Caused by: defining a function with an empty signature list. // Outcome: block accepted. contract_deploy_consensus_test!( @@ -2006,7 +2007,7 @@ contract_deploy_consensus_test!( contract_code: "(define-private () 1)", ); -// StaticCheckError: [`StaticCheckErrorKind::BadTupleFieldName`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTupleFieldName`] // Caused by: using `(get ...)` with a tuple field argument that is not an atom. // Outcome: block accepted. contract_deploy_consensus_test!( @@ -2015,7 +2016,7 @@ contract_deploy_consensus_test!( contract_code: "(get u1 (tuple (foo u0)))", ); -// StaticCheckError: [`StaticCheckErrorKind::BadMapName`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMapName`] // Caused by: passing a literal instead of a map identifier to `map-get?`. // Outcome: block accepted. contract_deploy_consensus_test!( @@ -2024,7 +2025,7 @@ contract_deploy_consensus_test!( contract_code: "(map-get? u1 (tuple (id u0)))", ); -// StaticCheckError: [`StaticCheckErrorKind::GetBlockInfoExpectPropertyName`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::GetBlockInfoExpectPropertyName`] // Caused by: calling `get-block-info` with a non-atom property argument. // Outcome: block accepted. // Note: Only Clarity 1 and 2 will trigger this error. Clarity 3 and 4 @@ -2035,7 +2036,7 @@ contract_deploy_consensus_test!( contract_code: "(get-block-info? u1 u0)", ); -// StaticCheckError: [`StaticCheckErrorKind::GetBurnBlockInfoExpectPropertyName`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::GetBurnBlockInfoExpectPropertyName`] // Caused by: calling `get-burn-block-info` with a non-atom property argument. // Outcome: block accepted. // Note: This error was added in Clarity 2. Clarity 1 will trigger @@ -2046,7 +2047,7 @@ contract_deploy_consensus_test!( contract_code: "(get-burn-block-info? u1 u0)", ); -// StaticCheckError: [`StaticCheckErrorKind::GetStacksBlockInfoExpectPropertyName`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::GetStacksBlockInfoExpectPropertyName`] // Caused by: calling `get-stacks-block-info` with a non-atom property argument. // Outcome: block accepted. // Note: This error was added in Clarity 3. Clarity 1 and 2 will trigger @@ -2057,7 +2058,7 @@ contract_deploy_consensus_test!( contract_code: "(get-stacks-block-info? u1 u0)", ); -// StaticCheckError: [`StaticCheckErrorKind::GetTenureInfoExpectPropertyName`] +// StaticCheckErrorKind: [`StaticCheckErrorKind::GetTenureInfoExpectPropertyName`] // Caused by: calling `get-tenure-info` with a non-atom property argument. // Outcome: block accepted. // Note: This error was added in Clarity 3. Clarity 1 and 2 will trigger @@ -2068,18 +2069,149 @@ contract_deploy_consensus_test!( contract_code: "(get-tenure-info? u1 u0)", ); +// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTraitImplementation`] +// Caused by: trying to implement a trait with a bad implementation. +// Outcome: block accepted. +#[test] +fn static_check_error_bad_trait_implementation() { + let contract_name = "contract-name"; + let contract_defining_trait = "(define-trait trait-1 ( + (get-1 ((list 10 uint)) (response uint uint))))"; + let impl_contract = format!( + "(impl-trait .{contract}.trait-1) + (define-public (get-1 (x (list 5 uint))) (ok u1))", + contract = contract_name + ); + + let mut nonce = 0; + + let tx_fee = (contract_defining_trait.len() * 100) as u64; + let mut epochs_blocks: HashMap> = HashMap::new(); + let deploy_tx = make_contract_publish_versioned( + &FAUCET_PRIV_KEY, + nonce, + tx_fee, + CHAIN_ID_TESTNET, + &contract_name, + &contract_defining_trait, + None, + ); + nonce += 1; + epochs_blocks + .entry(*EPOCHS_TO_TEST.first().unwrap()) + .or_insert(vec![]) + .push(TestBlock { + transactions: vec![ + StacksTransaction::consensus_deserialize(&mut deploy_tx.as_slice()).unwrap(), + ], + }); + + for epoch in EPOCHS_TO_TEST { + for version in clarity_versions_for_epoch(*epoch) { + let epoch_name = format!("Epoch{}", epoch.to_string().replace(".", "_")); + let name = format!( + "{contract_name}-{epoch_name}-{}", + version.to_string().replace(" ", "") + ); + let deploy_tx = make_contract_publish_versioned( + &FAUCET_PRIV_KEY, + nonce, + tx_fee, + CHAIN_ID_TESTNET, + &name, + &impl_contract, + Some(*version), + ); + nonce += 1; + + let deploy_tx = + StacksTransaction::consensus_deserialize(&mut deploy_tx.as_slice()).unwrap(); + + let entry = epochs_blocks + .entry(*epoch) + .or_insert(vec![]) + .push(TestBlock { + transactions: vec![deploy_tx], + }); + } + } + + let result = ConsensusTest::new(function_name!(), vec![]).run(epochs_blocks); + + insta::assert_ron_snapshot!(result); +} + +// Error: [`Error::InvalidStacksTransaction("Duplicate contract")`] +// Caused by: trying to deploy a contract that already exists. +// Outcome: block rejected. +#[test] +fn error_invalid_stacks_transaction_duplicate_contract() { + let contract_code = "(define-constant buff-0 0x00)"; + let mut nonce = 0; + + let tx_fee = (contract_code.len() * 100) as u64; + let mut epochs_blocks: HashMap> = HashMap::new(); + let contract_name = "contract-name"; + let deploy_tx = make_contract_publish_versioned( + &FAUCET_PRIV_KEY, + nonce, + tx_fee, + CHAIN_ID_TESTNET, + &contract_name, + &contract_code, + None, + ); + nonce += 1; + epochs_blocks + .entry(*EPOCHS_TO_TEST.first().unwrap()) + .or_insert(vec![]) + .push(TestBlock { + transactions: vec![ + StacksTransaction::consensus_deserialize(&mut deploy_tx.as_slice()).unwrap(), + ], + }); + + for epoch in EPOCHS_TO_TEST { + for version in clarity_versions_for_epoch(*epoch) { + let deploy_tx = make_contract_publish_versioned( + &FAUCET_PRIV_KEY, + nonce, + tx_fee, + CHAIN_ID_TESTNET, + &contract_name, + &contract_code, + Some(*version), + ); + + let deploy_tx = + StacksTransaction::consensus_deserialize(&mut deploy_tx.as_slice()).unwrap(); + + let entry = epochs_blocks + .entry(*epoch) + .or_insert(vec![]) + .push(TestBlock { + transactions: vec![deploy_tx], + }); + } + } + + let result = ConsensusTest::new(function_name!(), vec![]).run(epochs_blocks); + + insta::assert_ron_snapshot!(result); +} + // pub enum StaticCheckErrorKind { // CostOverflow, // Unreachable: should exceed u64 // CostBalanceExceeded(ExecutionCost, ExecutionCost), [`static_check_error_cost_balance_exceeded`] // MemoryBalanceExceeded(u64, u64), -// CostComputationFailed(String), -// ExecutionTimeExpired, +// CostComputationFailed(String), // Unreachable +// ExecutionTimeExpired, // Unreachable: can only be triggered at runtime. The CostError::ExecutionTimeExpired is immediately transformed into a VmExecutionError::Unchecked // ValueTooLarge, [`static_check_error_value_too_large`] // ValueOutOfBounds, [`static_check_error_value_out_of_bounds`] // TypeSignatureTooDeep, [`static_check_error_type_signature_too_deep`] // ExpectedName, [`static_check_error_expected_name`] // SupertypeTooLarge, [`static_check_error_supertype_too_large`] -// Expects(String), +// Expects(String), // unreachable // BadMatchOptionSyntax(Box), [`static_check_error_bad_match_option_syntax`] // BadMatchResponseSyntax(Box), [`static_check_error_bad_match_response_syntax`] // BadMatchInput(Box), [`static_check_error_bad_match_input`] @@ -2119,7 +2251,7 @@ contract_deploy_consensus_test!( // ReturnTypesMustMatch(Box, Box), [`static_check_error_return_types_must_match`] // NoSuchContract(String), [`static_check_error_no_such_contract`] // NoSuchPublicFunction(String, String), [`static_check_error_no_such_public_function`] -// ContractAlreadyExists(String), +// ContractAlreadyExists(String), Unreachable: during normal operations, `StacksChainState::process_transaction_payload` will check if the contract exists already, invalidating the block before executing analysis. // ContractCallExpectName, [`static_check_error_contract_call_expect_name`] // ExpectedCallableType(Box), [`static_check_error_expected_callable_type`] // NoSuchBlockInfoProperty(String), [`static_check_error_no_such_block_info_property`] @@ -2151,7 +2283,7 @@ contract_deploy_consensus_test!( // TraitReferenceUnknown(String), [`static_check_error_trait_reference_unknown`] // TraitMethodUnknown(String, String), [`static_check_error_trait_method_unknown`] // ExpectedTraitIdentifier, // Unreachable: (use-trait …) or (impl-trait …) with an invalid second argument fails in the AST stage, raising ParseErrorKind::ImportTraitBadSignature/ImplTraitBadSignature before static checks run. -// BadTraitImplementation(String, String), +// BadTraitImplementation(String, String), [`static_check_error_bad_trait_implementation`] // DefineTraitBadSignature, [`static_check_error_define_trait_bad_signature`] // DefineTraitDuplicateMethod(String), [`static_check_error_define_trait_duplicate_method`] // UnexpectedTraitOrFieldReference, [`static_check_error_unexpected_trait_or_field_reference`] @@ -2168,3 +2300,21 @@ contract_deploy_consensus_test!( // MaxIdentifierLengthExceeded(u32, u32), [`static_check_error_max_identifier_length_exceeded`] // TooManyAllowances(usize, usize), [`static_check_error_too_many_allowances`] // } + +// CheckError: [`CheckErrorKind::CostBalanceExceeded`] +// Caused by: exceeding the cost analysis budget during contract initialization. +// The contract repeatedly performs `var-get` lookups on a data variable, +// forcing the type checker to fetch the variable enough times to exceed +// the read-count limit in [`BLOCK_LIMIT_MAINNET_21`]. +// Outcome: block rejected. +contract_deploy_consensus_test!( + check_error_cost_balance_exceeded, + contract_name: "cost-balance-exceeded", + contract_code: &format!(" + (define-data-var foo int 1) + (begin + {} + )", + "(var-get foo)\n".repeat(BLOCK_LIMIT_MAINNET_21.read_count as usize + 1) + ), +); diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_cost_balance_exceeded.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_cost_balance_exceeded.snap new file mode 100644 index 00000000000..5fbf99d7ebf --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_cost_balance_exceeded.snap @@ -0,0 +1,13 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Failure("Invalid Stacks block afb3fc04ffeae6a2282b925c4f2d15dbf097d0f897216d55f020feacf61d13a2: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 255117, write_count: 4, read_length: 270001, read_count: 15001, runtime: 17953286 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block 6d622979478896d36d7c7f95e5b25563e16b01431e0fef12c35a68aa41f12f44: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 255117, write_count: 4, read_length: 270001, read_count: 15001, runtime: 17953285 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block b8709c0e888b0115790067bd98b22a23bb39856df28d64607f65556ca6a94097: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 255117, write_count: 4, read_length: 270001, read_count: 15001, runtime: 17953285 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block 5f947f7b9b5fb10dfeb65b80af7d0834ee2d45e4a5e1ed99bcdb9562c18a97e9: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 255117, write_count: 4, read_length: 270001, read_count: 15001, runtime: 17953286 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block b1a831538394bf3a62cc750b99896a64e9b42e180e7bcf9f9132b112acc060bf: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 255117, write_count: 4, read_length: 270001, read_count: 15001, runtime: 17953285 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block 43e4ca7163c0985ef4e6b78cd1c55049ad607448b6f5adca0674cee386dc953b: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 255117, write_count: 4, read_length: 270001, read_count: 15001, runtime: 17953285 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), + Failure("Invalid Stacks block 5f5589c88dc07eb78a293d4227732d41fcba3875399b05111b2073f92a3a2906: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 255117, write_count: 4, read_length: 270001, read_count: 15001, runtime: 17953285 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })"), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__error_invalid_stacks_transaction_duplicate_contract.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__error_invalid_stacks_transaction_duplicate_contract.snap new file mode 100644 index 00000000000..5fc8094b82b --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__error_invalid_stacks_transaction_duplicate_contract.snap @@ -0,0 +1,41 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "2b22aef17602253bb687f99c7b4fcfb768b914a4881cf4268876815df4ec808d", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-name, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 35, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8817, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 35, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8817, + ), + )), + Failure("Invalid Stacks block 7292f0b8e51a012ced35b53f84bb5d49a77f094207ded52206f0b22e0488179e: InvalidStacksTransaction(\"Duplicate contract \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-name\'\", false)"), + Failure("Invalid Stacks block b4282319a5d31899abf0adae46674ba12aab4014bfd39cc8ee774c96bf8e203d: InvalidStacksTransaction(\"Duplicate contract \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-name\'\", false)"), + Failure("Invalid Stacks block b4e79672497ec2f75c214f11d438752a254ef39230d6f6d15b2980303c67c706: InvalidStacksTransaction(\"Duplicate contract \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-name\'\", false)"), + Failure("Invalid Stacks block 424bd22e185de515489fa3ae787d05d42c764cc9f0ec8305660be3d98a486df8: InvalidStacksTransaction(\"Duplicate contract \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-name\'\", false)"), + Failure("Invalid Stacks block 2c5c6e2d7c3ec0c834785f1fddded708d99f5113c5cc208d8782301ab4e40ebb: InvalidStacksTransaction(\"Duplicate contract \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-name\'\", false)"), + Failure("Invalid Stacks block d3556ff730d25c9702927f8823dc60ce8edec663f37f093a0e458700ae7e5193: InvalidStacksTransaction(\"Duplicate contract \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-name\'\", false)"), + Failure("Invalid Stacks block d3242b8a3ed0e303d80d00b9394846dfd566efeceb6cddd19c935501089b5b07: InvalidStacksTransaction(\"Duplicate contract \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-name\'\", false)"), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_trait_implementation.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_trait_implementation.snap new file mode 100644 index 00000000000..d6c6b0349a3 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_bad_trait_implementation.snap @@ -0,0 +1,244 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "4c090fe3aa58d7aeafe400a2d86216cd132b44ea04fc85bd572af00cc7e6fa3a", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-name, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 96, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 10532, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 96, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 10532, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "661f5cd6b330234fae3c83baaf8417b9b2f184c818a4b23d6e10300fe318721a", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-name-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(invalid signature for method \'get-1\' regarding trait\'s specification ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a027ffca6d5988d4ccda18119690250d39cce861e8b1c5c38c4edd28978209eb", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-name-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(invalid signature for method \'get-1\' regarding trait\'s specification ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "659e2c86da3f9351eea33d937eec526a71ef55d6bd08724495c0adef6e6baac4", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-name-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(invalid signature for method \'get-1\' regarding trait\'s specification ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "593b946e45ae96b2389619e9514dbc4fcd1480203ffec5003f9a081b1dcf83a0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-name-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(invalid signature for method \'get-1\' regarding trait\'s specification ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "59f7b4d34ee8dd86fa0d218678086ab1c0e32878e02c54ca0b08c8c4847e841e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(invalid signature for method \'get-1\' regarding trait\'s specification ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ee1b07170a4a97bb030edc7b078c19a83c7de4c203dd1968553983917e74ef43", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-name-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(invalid signature for method \'get-1\' regarding trait\'s specification ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9047e29ae60abbefe556983e93560d137b650bdea8eb50e25a9fc386149d4860", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-name-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(invalid signature for method \'get-1\' regarding trait\'s specification ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 2779, + ), + )), +] From 2fedc147f30f796206a7897e2f9b5d173e27929c Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Wed, 12 Nov 2025 08:39:23 +0000 Subject: [PATCH 13/40] fix cost error conversion during contract analysis. Thanks ConsensusTest! --- clarity/src/vm/clarity.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/clarity/src/vm/clarity.rs b/clarity/src/vm/clarity.rs index bd06b628c46..418ad8a745a 100644 --- a/clarity/src/vm/clarity.rs +++ b/clarity/src/vm/clarity.rs @@ -78,7 +78,6 @@ impl std::error::Error for ClarityError { } } -#[cfg(any(test, feature = "testing"))] impl From for ClarityError { fn from(e: StaticCheckError) -> Self { match *e.err { @@ -258,7 +257,7 @@ pub trait TransactionConnection: ClarityConnection { let cost_track = contract_analysis.take_contract_cost_tracker(); (cost_track, Ok((contract_ast, contract_analysis))) } - Err(e) => (e.1, Err(ClarityError::StaticCheck(e.0))), + Err(e) => (e.1, Err(e.0.into())), } }) } From 614220272290c41fa541b8bdb0bdaa8bb1d1871e Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Wed, 12 Nov 2025 09:46:37 +0000 Subject: [PATCH 14/40] update CommonCheckErrorKind comments --- clarity-types/src/errors/analysis.rs | 28 +++++++++++----------------- clarity-types/src/errors/mod.rs | 4 ---- clarity/src/vm/analysis/errors.rs | 3 ++- clarity/src/vm/analysis/mod.rs | 4 +++- clarity/src/vm/errors.rs | 3 ++- 5 files changed, 18 insertions(+), 24 deletions(-) diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index 35925f02d39..d5de5c3ac2f 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -154,25 +154,19 @@ impl From for CommonCheckErrorKind { } } -/// Internal set of error variants that are shared exclusively between static analysis (deployment) -// and runtime checking (execution), specifically for validation logic that is implemented in common -// code paths used by both. +/// Shared set of error variants that are between static analysis (during contract deployment) +/// and runtime checking (during contract execution), specifically for validation logic that +/// is implemented in common code paths used by both. /// -/// **This enum is strictly for internal use and is not a part of the public API.** +/// All these variants represent errors that can arise only from code executed in both analysis and +/// execution contexts—such as argument count checks, type size limits, or shared cost tracking logic. +/// If an error may be triggered by either context via common logic, it lives here. /// -/// All these variants represent errors that can arise *only* from code executed in both analysis and execution -/// contexts—such as argument count checks, type size limits, or shared cost tracking logic. If an error -/// may be triggered by either context via common logic, it lives here. -/// -/// Importantly, this enum does *not* cover all errors common to both analysis and execution. +/// Importantly, this enum does not cover all errors common to both analysis and execution. /// There are other error shared error variants, but those are generated specifically by logic /// that is unique to static analysis or unique to execution. These errors are defined separately -/// and do not pass through this enum. Only error cases that can possibly arise from a shared validation -/// flow will appear here. -/// -/// When a `CommonCheckErrorKind` is produced, it is always converted immediately into either a -/// [`StaticCheckErrorKind`] (when encountered during deployment analysis) *or* a -/// [`CheckErrorKind`] (when encountered at runtime). +/// and do not pass through this enum. Only error cases that can possibly arise from a shared +/// validation flow will appear here. #[derive(Debug, PartialEq)] pub enum CommonCheckErrorKind { // Cost checker errors @@ -862,8 +856,7 @@ pub struct StaticCheckError { } impl CheckErrorKind { - /// Does this check error indicate that the transaction should be - /// rejected? + /// This check indicates that the transaction should be rejected. pub fn rejectable(&self) -> bool { matches!( self, @@ -873,6 +866,7 @@ impl CheckErrorKind { } impl StaticCheckErrorKind { + /// This check indicates that the transaction should be rejected. pub fn rejectable(&self) -> bool { matches!( self, diff --git a/clarity-types/src/errors/mod.rs b/clarity-types/src/errors/mod.rs index a4586953245..957fef5ef25 100644 --- a/clarity-types/src/errors/mod.rs +++ b/clarity-types/src/errors/mod.rs @@ -295,8 +295,6 @@ impl From for VmExecutionError { } } -// TODO: remove. CommonCheckErrorKind shouldn't be used in the public API. -// So there shouldn't be any need to convert it to a VmExecutionError. impl From for VmExecutionError { fn from(err: CommonCheckErrorKind) -> Self { VmExecutionError::Unchecked(err.into()) @@ -309,8 +307,6 @@ impl From for VmExecutionError { } } -// TODO: remove. CommonCheckErrorKind shouldn't be used in the public API. -// So there shouldn't be any need to convert it to a VmExecutionError. impl From<(CommonCheckErrorKind, &SymbolicExpression)> for VmExecutionError { fn from(err: (CommonCheckErrorKind, &SymbolicExpression)) -> Self { VmExecutionError::Unchecked(err.0.into()) diff --git a/clarity/src/vm/analysis/errors.rs b/clarity/src/vm/analysis/errors.rs index c7e326e6a6e..15002f5a15d 100644 --- a/clarity/src/vm/analysis/errors.rs +++ b/clarity/src/vm/analysis/errors.rs @@ -16,5 +16,6 @@ pub use clarity_types::errors::analysis::{ check_argument_count, check_arguments_at_least, check_arguments_at_most, CheckErrorKind, - StaticCheckError, StaticCheckErrorKind, SyntaxBindingError, SyntaxBindingErrorType, + CommonCheckErrorKind, StaticCheckError, StaticCheckErrorKind, SyntaxBindingError, + SyntaxBindingErrorType, }; diff --git a/clarity/src/vm/analysis/mod.rs b/clarity/src/vm/analysis/mod.rs index 9da98099d2e..4bc15d41944 100644 --- a/clarity/src/vm/analysis/mod.rs +++ b/clarity/src/vm/analysis/mod.rs @@ -28,7 +28,9 @@ use stacks_common::types::StacksEpochId; pub use self::analysis_db::AnalysisDatabase; use self::arithmetic_checker::ArithmeticOnlyChecker; use self::contract_interface_builder::build_contract_interface; -pub use self::errors::{CheckErrorKind, StaticCheckError, StaticCheckErrorKind}; +pub use self::errors::{ + CheckErrorKind, CommonCheckErrorKind, StaticCheckError, StaticCheckErrorKind, +}; use self::read_only_checker::ReadOnlyChecker; use self::trait_checker::TraitChecker; use self::type_checker::v2_05::TypeChecker as TypeChecker2_05; diff --git a/clarity/src/vm/errors.rs b/clarity/src/vm/errors.rs index 11341ea05b5..04d712a60dd 100644 --- a/clarity/src/vm/errors.rs +++ b/clarity/src/vm/errors.rs @@ -21,7 +21,8 @@ pub use clarity_types::errors::{ pub use crate::vm::analysis::errors::{ check_argument_count, check_arguments_at_least, check_arguments_at_most, CheckErrorKind, - StaticCheckError, StaticCheckErrorKind, SyntaxBindingError, SyntaxBindingErrorType, + CommonCheckErrorKind, StaticCheckError, StaticCheckErrorKind, SyntaxBindingError, + SyntaxBindingErrorType, }; #[cfg(test)] From 1554bac596bf3501e7283a70aea7d5ee58c94375 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Wed, 12 Nov 2025 09:47:37 +0000 Subject: [PATCH 15/40] replace fuzz error CheckErrorKind::TraitReferenceNotAllowed with TraitReferenceUnknown --- clarity/fuzz/fuzz_targets/fuzz_sanitize.rs | 144 +++++++++--------- .../fuzz/fuzz_targets/fuzz_value_sanitize.rs | 4 +- 2 files changed, 79 insertions(+), 69 deletions(-) diff --git a/clarity/fuzz/fuzz_targets/fuzz_sanitize.rs b/clarity/fuzz/fuzz_targets/fuzz_sanitize.rs index 7b509750abe..298151e096f 100644 --- a/clarity/fuzz/fuzz_targets/fuzz_sanitize.rs +++ b/clarity/fuzz/fuzz_targets/fuzz_sanitize.rs @@ -16,24 +16,17 @@ #![no_main] use arbitrary::Arbitrary; -use clarity::vm::types::TypeSignature; -use clarity::vm::types::signatures::SequenceSubtype; -use clarity::vm::Value as ClarityValue; -use clarity::vm::types::SequenceData; -use clarity::vm::types::PrincipalData; -use clarity::vm::types::StandardPrincipalData; -use clarity::vm::types::QualifiedContractIdentifier; -use clarity::vm::types::TupleData; -use clarity::vm::types::CharType; -use clarity::vm::ClarityName; +use clarity::vm::analysis::CheckErrorKind; use clarity::vm::representations::ContractName; use clarity::vm::types::serialization::SerializationError; +use clarity::vm::types::signatures::SequenceSubtype; +use clarity::vm::types::{ + CharType, PrincipalData, QualifiedContractIdentifier, SequenceData, StandardPrincipalData, + StringSubtype, TupleData, TypeSignature, +}; +use clarity::vm::{ClarityName, Value as ClarityValue}; +use libfuzzer_sys::{arbitrary, fuzz_target}; use stacks_common::types::StacksEpochId; -use clarity::vm::analysis::CheckErrorKind; -use clarity::vm::types::StringSubtype; - -use libfuzzer_sys::arbitrary; -use libfuzzer_sys::fuzz_target; #[derive(Debug)] struct FuzzClarityValue(ClarityValue); @@ -92,11 +85,15 @@ impl arbitrary::Arbitrary<'_> for FuzzClarityValue { .map_err(|_| arbitrary::Error::IncorrectFormat)?, 6 => ClarityValue::error(FuzzClarityValue::arbitrary(u)?.0) .map_err(|_| arbitrary::Error::IncorrectFormat)?, - 7 => ClarityValue::Principal(PrincipalData::Standard(FuzzStandardPrincipal::arbitrary(u)?.0)), - 8 => ClarityValue::Principal(PrincipalData::Contract(QualifiedContractIdentifier::new( + 7 => ClarityValue::Principal(PrincipalData::Standard( FuzzStandardPrincipal::arbitrary(u)?.0, - FuzzContractName::arbitrary(u)?.0, - ))), + )), + 8 => { + ClarityValue::Principal(PrincipalData::Contract(QualifiedContractIdentifier::new( + FuzzStandardPrincipal::arbitrary(u)?.0, + FuzzContractName::arbitrary(u)?.0, + ))) + } // utf8 9 => ClarityValue::string_utf8_from_bytes(Arbitrary::arbitrary(u)?) .map_err(|_| arbitrary::Error::IncorrectFormat)?, @@ -111,7 +108,7 @@ impl arbitrary::Arbitrary<'_> for FuzzClarityValue { let value_vec: Vec = Arbitrary::arbitrary(u)?; ClarityValue::cons_list_unsanitized(value_vec.into_iter().map(|x| x.0).collect()) .map_err(|_| arbitrary::Error::IncorrectFormat)? - }, + } // tuple 13 => { let tuple_data: Vec<(FuzzClarityName, FuzzClarityValue)> = Arbitrary::arbitrary(u)?; @@ -119,11 +116,11 @@ impl arbitrary::Arbitrary<'_> for FuzzClarityValue { tuple_data .into_iter() .map(|(key, value)| (key.0, value.0)) - .collect() - ) - .map_err(|_| arbitrary::Error::IncorrectFormat)? - .into() - }, + .collect(), + ) + .map_err(|_| arbitrary::Error::IncorrectFormat)? + .into() + } _ => return Err(arbitrary::Error::IncorrectFormat), }; @@ -161,7 +158,7 @@ pub fn strict_admits(me: &TypeSignature, x: &ClarityValue) -> Result { let buff_data = match x { ClarityValue::Sequence(SequenceData::Buffer(ref buff_data)) => buff_data, @@ -171,37 +168,46 @@ pub fn strict_admits(me: &TypeSignature, x: &ClarityValue) -> Result { + } + TypeSignature::SequenceType(SequenceSubtype::StringType(StringSubtype::ASCII( + ref my_max_len, + ))) => { let ascii_data = match x { - ClarityValue::Sequence(SequenceData::String(CharType::ASCII(ref ascii_data))) => ascii_data, + ClarityValue::Sequence(SequenceData::String(CharType::ASCII(ref ascii_data))) => { + ascii_data + } _ => return Ok(false), }; if ascii_data.len().map_or(false, |n| &n > my_max_len) { return Ok(false); } return Ok(true); - }, - TypeSignature::SequenceType(SequenceSubtype::StringType(StringSubtype::UTF8(ref my_max_len))) => { + } + TypeSignature::SequenceType(SequenceSubtype::StringType(StringSubtype::UTF8( + ref my_max_len, + ))) => { let utf8_data = match x { - ClarityValue::Sequence(SequenceData::String(CharType::UTF8(ref utf8_data))) => utf8_data, + ClarityValue::Sequence(SequenceData::String(CharType::UTF8(ref utf8_data))) => { + utf8_data + } _ => return Ok(false), }; - if utf8_data.len().map_or(false, |n| u32::from(n) > u32::from(my_max_len.clone())) { + if utf8_data + .len() + .map_or(false, |n| u32::from(n) > u32::from(my_max_len.clone())) + { return Ok(false); } return Ok(true); - }, + } TypeSignature::PrincipalType => match x { ClarityValue::Principal(_) => Ok(true), _ => Ok(false), }, TypeSignature::OptionalType(ref ot) => match x { - ClarityValue::Optional(inner_value) => { - match &inner_value.data { - Some(some_value) => strict_admits(ot, some_value), - None => Ok(true), - } + ClarityValue::Optional(inner_value) => match &inner_value.data { + Some(some_value) => strict_admits(ot, some_value), + None => Ok(true), }, _ => Ok(false), }, @@ -216,29 +222,31 @@ pub fn strict_admits(me: &TypeSignature, x: &ClarityValue) -> Result { let tuple_data = match x { ClarityValue::Tuple(td) => td, _ => return Ok(false), }; if tt.len() != tuple_data.len() { - return Ok(false) + return Ok(false); } for (field, field_type) in tt.get_type_map().iter() { let field_value = match tuple_data.get(&field) { Ok(x) => x, - Err(_) => return Ok(false) + Err(_) => return Ok(false), }; if !strict_admits(field_type, field_value)? { return Ok(false); } } return Ok(true); - }, - TypeSignature::CallableType(_) | - TypeSignature::ListUnionType(_) | - TypeSignature::TraitReferenceType(_) => Err(CheckErrorKind::TraitReferenceNotAllowed), + } + TypeSignature::CallableType(_) + | TypeSignature::ListUnionType(_) + | TypeSignature::TraitReferenceType(_) => Err(CheckErrorKind::TraitReferenceUnknown( + "Unknown trait reference".into(), + )), } } @@ -250,11 +258,9 @@ fn fuzz_sanitize(input: ClarityValue) { let computed_type = TypeSignature::type_of(&input).unwrap(); let did_strict_admit = strict_admits(&computed_type, &input).unwrap(); - let (sanitized_value, did_sanitize) = ClarityValue::sanitize_value( - &StacksEpochId::Epoch24, - &computed_type, - input.clone() - ).unwrap(); + let (sanitized_value, did_sanitize) = + ClarityValue::sanitize_value(&StacksEpochId::Epoch24, &computed_type, input.clone()) + .unwrap(); if did_strict_admit { assert_eq!(input, sanitized_value); @@ -265,11 +271,8 @@ fn fuzz_sanitize(input: ClarityValue) { } let serialized = input.serialize_to_vec().expect("serialize input"); - let deserialize_unsanitized = ClarityValue::deserialize_read( - &mut serialized.as_slice(), - Some(&computed_type), - false - ); + let deserialize_unsanitized = + ClarityValue::deserialize_read(&mut serialized.as_slice(), Some(&computed_type), false); if !did_strict_admit { deserialize_unsanitized.unwrap_err(); } else { @@ -280,9 +283,10 @@ fn fuzz_sanitize(input: ClarityValue) { ClarityValue::deserialize_read( &mut serialized.as_slice(), Some(&computed_type), - true - ).unwrap() - }, + true, + ) + .unwrap() + } deser_result => deser_result.unwrap(), }; assert_eq!(deser_value, input); @@ -291,17 +295,19 @@ fn fuzz_sanitize(input: ClarityValue) { let deserialize_sanitized = match ClarityValue::deserialize_read( &mut serialized.as_slice(), Some(&computed_type), - true + true, ) { Ok(x) => x, Err(SerializationError::BadTypeError(CheckErrorKind::TypeSignatureTooDeep)) => { assert!(!did_strict_admit, "Unsanitized inputs may fail to deserialize, but they must have needed sanitization"); // check that the sanitized value *is* readable - let serialized = sanitized_value.serialize_to_vec().expect("serialize sanitized"); + let serialized = sanitized_value + .serialize_to_vec() + .expect("serialize sanitized"); let deserialize_unsanitized = match ClarityValue::deserialize_read( &mut serialized.as_slice(), Some(&computed_type), - false + false, ) { Err(SerializationError::BadTypeError(CheckErrorKind::TypeSignatureTooDeep)) => { // pre-2.4, deserializer could error on legal types deeper than a deserialization limit of 16. @@ -309,9 +315,10 @@ fn fuzz_sanitize(input: ClarityValue) { ClarityValue::deserialize_read( &mut serialized.as_slice(), Some(&computed_type), - true - ).unwrap() - }, + true, + ) + .unwrap() + } deser_result => deser_result.unwrap(), }; assert_eq!(deserialize_unsanitized, sanitized_value); @@ -319,13 +326,14 @@ fn fuzz_sanitize(input: ClarityValue) { let deserialize_sanitized = ClarityValue::deserialize_read( &mut serialized.as_slice(), Some(&computed_type), - true - ).unwrap(); + true, + ) + .unwrap(); assert_eq!(deserialize_sanitized, sanitized_value); assert!(strict_admits(&computed_type, &deserialize_sanitized).unwrap()); return; } - Err(e) => panic!("Unexpected error from deserialization: {}", e) + Err(e) => panic!("Unexpected error from deserialization: {}", e), }; assert!(strict_admits(&computed_type, &deserialize_sanitized).unwrap()); diff --git a/clarity/fuzz/fuzz_targets/fuzz_value_sanitize.rs b/clarity/fuzz/fuzz_targets/fuzz_value_sanitize.rs index 52c983daecb..79bad892823 100644 --- a/clarity/fuzz/fuzz_targets/fuzz_value_sanitize.rs +++ b/clarity/fuzz/fuzz_targets/fuzz_value_sanitize.rs @@ -251,7 +251,9 @@ pub fn strict_admits(me: &TypeSignature, x: &ClarityValue) -> Result Err(CheckErrorKind::TraitReferenceNotAllowed), + | TypeSignature::TraitReferenceType(_) => Err(CheckErrorKind::TraitReferenceUnknown( + "Unknown trait reference".into(), + )), } } From 86de7f53db9068459ec2156db2baaf7bfcdd1b52 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Wed, 12 Nov 2025 10:32:21 +0000 Subject: [PATCH 16/40] add consensus tests for TraitTooManyMethods and TooManyFunctionParameters --- stackslib/src/chainstate/tests/consensus.rs | 33 +++ ...ck_error_too_many_function_parameters.snap | 210 ++++++++++++++++++ ...ic_check_error_trait_too_many_methods.snap | 210 ++++++++++++++++++ 3 files changed, 453 insertions(+) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_too_many_function_parameters.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_too_many_methods.snap diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index 26d6d57e92e..f37e6a0f017 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -27,6 +27,7 @@ use clarity::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKe use clarity::types::{StacksEpoch, StacksEpochId}; use clarity::util::hash::{MerkleTree, Sha512Trunc256Sum}; use clarity::util::secp256k1::MessageSignature; +use clarity::vm::analysis::type_checker::v2_1::{MAX_FUNCTION_PARAMETERS, MAX_TRAIT_METHODS}; use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER; use clarity::vm::costs::ExecutionCost; use clarity::vm::types::{PrincipalData, MAX_TYPE_DEPTH}; @@ -1757,6 +1758,36 @@ contract_deploy_consensus_test!( (contract-call? contract get-2 u1))", ); +// StaticCheckErrorKind: [`StaticCheckErrorKind::TraitTooManyMethods`] +// Caused by: a trait has too many methods. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_trait_too_many_methods, + contract_name: "too-many-methods", + contract_code: &format!( + "(define-trait trait-1 ({}))", + (0..(MAX_TRAIT_METHODS + 1)) + .map(|i| format!("(method-{i} (uint) (response uint uint))")) + .collect::>() + .join(" ") + ), +); + +// StaticCheckErrorKind: [`StaticCheckErrorKind::TooManyFunctionParameters`] +// Caused by: a function has too many parameters. +// Outcome: block accepted. +contract_deploy_consensus_test!( + static_check_error_too_many_function_parameters, + contract_name: "too-many-params", + contract_code: &format!( + "(define-trait trait-1 ((method ({}) (response uint uint))))", + (0..(MAX_FUNCTION_PARAMETERS + 1)) + .map(|i| "uint".to_string()) + .collect::>() + .join(" ") + ), +); + // StaticCheckErrorKind: [`StaticCheckErrorKind::ReservedWord`] // Caused by: name is a reserved word // Outcome: block accepted. @@ -2279,6 +2310,7 @@ fn error_invalid_stacks_transaction_duplicate_contract() { // DefaultTypesMustMatch(Box, Box), [`static_check_error_default_types_must_match`] // IllegalOrUnknownFunctionApplication(String), [`static_check_error_illegal_or_unknown_function_application`] // UnknownFunction(String), [`static_check_error_unknown_function`] +// TooManyFunctionParameters(usize, usize), [`static_check_error_too_many_function_parameters`] // NoSuchTrait(String, String), // Unreachable: all trait identifiers are validated by the parser and TraitsResolve before type checking; invalid or missing traits trigger TraitReferenceUnknown earlier, so this error is never returned. // TraitReferenceUnknown(String), [`static_check_error_trait_reference_unknown`] // TraitMethodUnknown(String, String), [`static_check_error_trait_method_unknown`] @@ -2289,6 +2321,7 @@ fn error_invalid_stacks_transaction_duplicate_contract() { // UnexpectedTraitOrFieldReference, [`static_check_error_unexpected_trait_or_field_reference`] // ContractOfExpectsTrait, [`static_check_error_contract_of_expects_trait`] // IncompatibleTrait(Box, Box), [`static_check_error_incompatible_trait`] +// TraitTooManyMethods(usize, usize), [`static_check_error_trait_too_many_methods`] // WriteAttemptedInReadOnly, [`static_check_error_write_attempted_in_read_only`] // AtBlockClosureMustBeReadOnly, [`static_check_error_at_block_closure_must_be_read_only`] // ExpectedListOfAllowances(String, i32), [`static_check_error_expected_list_of_allowances`] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_too_many_function_parameters.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_too_many_function_parameters.snap new file mode 100644 index 00000000000..2d302d944ea --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_too_many_function_parameters.snap @@ -0,0 +1,210 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "6b5b459445333ac0d89a15f2d8017fe8b1fdc54c86d32b46c6cc85e685a55664", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-params-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 1611, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 60265, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1611, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 60265, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5f019ae2d609b6052e68164d296a62b1d378bd99577a36443dc6fbcda94b22de", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-params-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 1611, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 60265, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1611, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 60265, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8ba488c09d31d904bb854be6c99a37365f4175479672f294316ebee352d12981", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-params-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 1611, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 60265, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1611, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 60265, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "04df16e1f66ae19e8e784465084fdf72be32d1a7a570187579c277154677af57", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-params-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: too many function parameters specified: found 257, the maximum is 256) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 269, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 36990, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 269, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 36990, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e912df8753953413cf03f5140638a2d14fad57d5d55342a37e925b1498a85baf", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-params-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: too many function parameters specified: found 257, the maximum is 256) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 269, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 36990, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 269, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 36990, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f091da615624ae416bb035ae023e916feff1c0c8308ebba8969b02fe2421d3bc", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-params-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: too many function parameters specified: found 257, the maximum is 256) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 269, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 36990, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 269, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 36990, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "84f8fd1233c72584994325db176e47da082a8bd1100d9a734a6e21eed8021c8f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-params-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: too many function parameters specified: found 257, the maximum is 256) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 269, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 36990, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 269, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 36990, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_too_many_methods.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_too_many_methods.snap new file mode 100644 index 00000000000..465d53f3693 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__static_check_error_trait_too_many_methods.snap @@ -0,0 +1,210 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "d908588ae336b7a6c33ed433cdf084f0ac1d05afca3da2d4f5fed60c40a84349", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-methods-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 12513, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 413869, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 12513, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 413869, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2d0ed096c554b964cd02a9e6fe324abc142add8030d02596751400951be56574", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-methods-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 12513, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 413869, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 12513, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 413869, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a4251994b4652ea7a2e9e75109d306b10a43f5b9d9331b3b0caae90c6b2da121", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-methods-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 12513, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 413869, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 12513, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 413869, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9f680b87815c32a02b903173bbdf7f399bda2c2c501ee903565f34faa0edc309", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-methods-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: too many trait methods specified: found 257, the maximum is 256) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 2061, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 286544, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 2061, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 286544, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0c615837eb5f03dd9d35e48ab6cd08cc44441007f503bd25bd416b1299a76b7c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-methods-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: too many trait methods specified: found 257, the maximum is 256) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 2061, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 286544, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 2061, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 286544, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "19fce739e60ca24b7f6f9cad68a5e4fd7369fa62cb686eaebcefe4535496ce87", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-methods-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: too many trait methods specified: found 257, the maximum is 256) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 2061, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 286544, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 2061, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 286544, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "66091464ad1cdbbbe267993370ee466b261146b582cdc88adb14c862d4fbc7c6", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: too-many-methods-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: too many trait methods specified: found 257, the maximum is 256) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 2061, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 286544, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 2061, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 286544, + ), + )), +] From 55236a1aa311ef0245338fe9c71e94f6755a96a6 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Fri, 14 Nov 2025 10:31:33 +0000 Subject: [PATCH 17/40] add tests for CheckErrorKind::TypeSignatureTooDeep and CheckErrorKind::ValueTooLarge --- stackslib/src/chainstate/tests/consensus.rs | 178 +++++++++++++++ ...ck_error_kind_type_signature_too_deep.snap | 216 ++++++++++++++++++ ...sus__check_error_kind_value_too_large.snap | 216 ++++++++++++++++++ 3 files changed, 610 insertions(+) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_kind_type_signature_too_deep.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_kind_value_too_large.snap diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index f37e6a0f017..41f8fdb7280 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -2351,3 +2351,181 @@ contract_deploy_consensus_test!( "(var-get foo)\n".repeat(BLOCK_LIMIT_MAINNET_21.read_count as usize + 1) ), ); + +// CheckErrorKind: [`CheckErrorKind::ValueTooLarge`] +// Caused by: `(as-max-len? …)` wraps a buffer whose serialized size plus the optional wrapper +// exceeds `MAX_VALUE_SIZE`. Static analysis allows this construction, but initialization fails +// at runtime when `Value::some` detects the oversized payload. +// Outcome: block accepted. +contract_deploy_consensus_test!( + check_error_kind_value_too_large, + contract_name: "value-too-large", + contract_code: r#" + (define-private (make-buff-256) + (let ((b16 0x00112233445566778899aabbccddeeff) + (b32 (concat b16 b16)) + (b64 (concat b32 b32)) + (b128 (concat b64 b64)) + (b256 (concat b128 b128))) + b256)) + + (define-private (make-buff-4096) + (let ((b256 (make-buff-256)) + (b512 (concat b256 b256)) + (b1024 (concat b512 b512)) + (b2048 (concat b1024 b1024)) + (b4096 (concat b2048 b2048))) + b4096)) + + (define-private (make-buff-65536) + (let ((b4096 (make-buff-4096)) + (b8192 (concat b4096 b4096)) + (b16384 (concat b8192 b8192)) + (b32768 (concat b16384 b16384)) + (b65536 (concat b32768 b32768))) + b65536)) + + (define-private (make-buff-1048576) + (let ((b65536 (make-buff-65536)) + (b131072 (concat b65536 b65536)) + (b262144 (concat b131072 b131072)) + (b524288 (concat b262144 b262144)) + (b1048576 (concat b524288 b524288))) + b1048576)) + + (begin + (unwrap-panic (as-max-len? (make-buff-1048576) u1048576)) + u0) + "#, +); + +// CheckErrorKind: [`CheckErrorKind::TypeSignatureTooDeep`] +// Caused by: inserting into a map whose value type already has depth `MAX_TYPE_DEPTH`. +// The runtime wraps stored entries in an optional, pushing the depth past the limit. +// Outcome: block accepted. +contract_deploy_consensus_test!( + check_error_kind_type_signature_too_deep, + contract_name: "type-depth-runtime", + contract_code: &{ + let optional_layers: usize = MAX_TYPE_DEPTH as usize - 2; + + let mut value_type = String::new(); + for _ in 0..optional_layers { + value_type.push_str("(optional "); + } + value_type.push_str("uint"); + for _ in 0..optional_layers { + value_type.push(')'); + } + + let mut let_bindings = String::from("(v0 u0)"); + for i in 1..=optional_layers { + let_bindings.push_str("\n "); + let_bindings.push_str(&format!("(v{i} (some v{}))", i - 1)); + } + let final_var = format!("v{optional_layers}"); + + format!( + "(define-map deep {{ key: uint }} {{ data: {value_type} }}) + (define-constant deep-value + (let ( + {let_bindings} + ) + {final_var})) + (begin + (map-insert deep (tuple (key u0)) (tuple (data deep-value))) + u0)" + ) + }, +); + +// pub enum CheckErrorKind { +// CostOverflow, // Unreachable: should exceed u64 +// CostBalanceExceeded(ExecutionCost, ExecutionCost), [`check_error_cost_balance_exceeded`] +// MemoryBalanceExceeded(u64, u64), +// CostComputationFailed(String), // Unreachable +// ExecutionTimeExpired, +// ValueTooLarge, [`check_error_kind_value_too_large`] +// ValueOutOfBounds, +// TypeSignatureTooDeep, [`check_error_kind_type_signature_too_deep`] +// ExpectedName, +// SupertypeTooLarge, +// Expects(String), +// BadMatchOptionSyntax(Box), +// BadMatchResponseSyntax(Box), +// BadMatchInput(Box), +// ListTypesMustMatch, +// TypeError(Box, Box), +// TypeValueError(Box, Box), +// InvalidTypeDescription, +// UnknownTypeName(String), +// UnionTypeError(Vec, Box), +// UnionTypeValueError(Vec, Box), +// ExpectedOptionalValue(Box), +// ExpectedResponseValue(Box), +// ExpectedOptionalOrResponseValue(Box), +// ExpectedContractPrincipalValue(Box), +// CouldNotDetermineType, +// BadTokenName, +// NoSuchNFT(String), +// NoSuchFT(String), +// BadTransferSTXArguments, +// BadTransferFTArguments, +// BadTransferNFTArguments, +// BadMintFTArguments, +// BadBurnFTArguments, +// ExpectedTuple(Box), +// NoSuchTupleField(String, TupleTypeSignature), +// EmptyTuplesNotAllowed, +// NoSuchDataVariable(String), +// NoSuchMap(String), +// DefineFunctionBadSignature, +// BadFunctionName, +// PublicFunctionMustReturnResponse(Box), +// ReturnTypesMustMatch(Box, Box), +// CircularReference(Vec), +// NoSuchContract(String), +// NoSuchPublicFunction(String, String), +// PublicFunctionNotReadOnly(String, String), +// ContractAlreadyExists(String), +// ContractCallExpectName, +// NoSuchBurnBlockInfoProperty(String), +// NoSuchStacksBlockInfoProperty(String), +// GetBlockInfoExpectPropertyName, +// GetStacksBlockInfoExpectPropertyName, +// GetTenureInfoExpectPropertyName, +// NameAlreadyUsed(String), +// NonFunctionApplication, +// ExpectedListApplication, +// ExpectedSequence(Box), +// BadLetSyntax, +// BadSyntaxBinding(SyntaxBindingError), +// UndefinedFunction(String), +// UndefinedVariable(String), +// RequiresAtLeastArguments(usize, usize), +// RequiresAtMostArguments(usize, usize), +// IncorrectArgumentCount(usize, usize), +// TooManyFunctionParameters(usize, usize), +// TraitReferenceUnknown(String), +// TraitMethodUnknown(String, String), +// ExpectedTraitIdentifier, +// BadTraitImplementation(String, String), +// DefineTraitBadSignature, +// DefineTraitDuplicateMethod(String), +// TraitBasedContractCallInReadOnly, +// ContractOfExpectsTrait, +// TraitTooManyMethods(usize, usize), +// InvalidCharactersDetected, +// InvalidUTF8Encoding, +// InvalidSecp65k1Signature, +// WriteAttemptedInReadOnly, +// AtBlockClosureMustBeReadOnly, +// ExpectedListOfAllowances(String, i32), +// AllowanceExprNotAllowed, +// ExpectedAllowanceExpr(String), +// WithAllAllowanceNotAllowed, +// WithAllAllowanceNotAlone, +// WithNftExpectedListOfIdentifiers, +// MaxIdentifierLengthExceeded(u32, u32), +// TooManyAllowances(usize, usize), +// } diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_kind_type_signature_too_deep.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_kind_type_signature_too_deep.snap new file mode 100644 index 00000000000..696bfc87513 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_kind_type_signature_too_deep.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "260c6eacb8d0e783617d39fe22298c616c334a78385984fd619b4d419830cf33", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-depth-runtime-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(TypeSignatureTooDeep) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2f384e5f90b56e4fcba03d6593cc0fe62644f85659a3b23644e9d525561e820e", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-depth-runtime-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(TypeSignatureTooDeep) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e2b4cffe467cbca3915970d561b46e02130338499c8b2aca684bf93f07a32b6a", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-depth-runtime-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(TypeSignatureTooDeep) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ebd341c751915ab363eca51b8b68361a70ef9e566436e52701cd26c4fd303087", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-depth-runtime-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(TypeSignatureTooDeep) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bbf8d24a4d943e17a8ecc4fad812de86bcbd9a3b9b49b77004450daefed5a9ba", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-depth-runtime-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(TypeSignatureTooDeep) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d871c0f4c04d7c6e09855041fbe76221adb5a3f22fcba3b6be06032a8546a67b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-depth-runtime-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(TypeSignatureTooDeep) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "05f93466c51af46d73fa65789cd5e8013b379b2eee7908e7b179bb344d9455c3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: type-depth-runtime-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(TypeSignatureTooDeep) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1963, + write_count: 4, + read_length: 1, + read_count: 2, + runtime: 95289, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_kind_value_too_large.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_kind_value_too_large.snap new file mode 100644 index 00000000000..476334d9830 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__consensus__check_error_kind_value_too_large.snap @@ -0,0 +1,216 @@ +--- +source: stackslib/src/chainstate/tests/consensus.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "08fdefabcef0134a25b3b0069cee43a2f95764c76806066aadada4dd7e5f8567", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(ValueTooLarge) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d6dd58f60ae2ea943ebd9e6cae0f44156f562b2599e4889cc957d9f273d8e98f", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(ValueTooLarge) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7138a8f6ab4a474e996f8485f0432a2117b3d996bb7cd17842bd7ca95a1a3695", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(ValueTooLarge) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "215b5ae1d1f726522dc6dfed4bae9a52ae5ef64662a48026bd5ccd19a67c84c7", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(ValueTooLarge) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "066a6017f381674750ca2f50ccb4b7aa3ab0117ec9ad0c2eb58dd9f62eef4da3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(ValueTooLarge) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ca211897f91549c5b105079425f75c4b7ebe7a5c6fcda7ed6934dddd30ebe226", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(ValueTooLarge) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "08378d0ef05482a88ea610c5df9a7ceae18b0cffa8883d9f687b6d278d15dcb4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: value-too-large-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(ValueTooLarge) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 1472, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 84104599, + ), + )), +] From 4ffb007471bb5415d4b8e871b2b441dbd2b21791 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Fri, 14 Nov 2025 17:44:02 +0000 Subject: [PATCH 18/40] add check_error_kind_name_already_used test --- stackslib/src/chainstate/tests/consensus.rs | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index 41f8fdb7280..c317db61da6 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -1792,7 +1792,7 @@ contract_deploy_consensus_test!( // Caused by: name is a reserved word // Outcome: block accepted. // Note: This error was added in Clarity 3. Clarity 1 and 2 -// will trigger a [`StaticCheckErrorKind::NameAlreadyUsed`]. +// will trigger a [`CheckErrorKind::NameAlreadyUsed`]. contract_deploy_consensus_test!( static_check_error_reserved_word, contract_name: "reserved-word", @@ -2352,6 +2352,15 @@ contract_deploy_consensus_test!( ), ); +// CheckError: [`CheckErrorKind::NameAlreadyUsed`] +// Caused by: name is already used by a standard clarity function. +// Outcome: block rejected. +contract_deploy_consensus_test!( + check_error_kind_name_already_used, + contract_name: "name-already-used", + contract_code: "(define-private (ft-get-supply) 1)", +); + // CheckErrorKind: [`CheckErrorKind::ValueTooLarge`] // Caused by: `(as-max-len? …)` wraps a buffer whose serialized size plus the optional wrapper // exceeds `MAX_VALUE_SIZE`. Static analysis allows this construction, but initialization fails From 19a5ece2611b8b169b454c590f041599a26b4278 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Tue, 18 Nov 2025 15:04:11 +0000 Subject: [PATCH 19/40] add first round of runtime analysis tests --- .../tests/runtime_analysis_tests.rs | 265 +++ ...eck_error_kind_type_value_error_ccall.snap | 1456 +++++++++++++++++ ...k_error_kind_type_value_error_cdeploy.snap | 126 ++ ...tic_check_error_cost_balance_exceeded.snap | 22 - 4 files changed, 1847 insertions(+), 22 deletions(-) create mode 100644 stackslib/src/chainstate/tests/runtime_analysis_tests.rs create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_value_error_ccall.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_value_error_cdeploy.snap delete mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_cost_balance_exceeded.snap diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs new file mode 100644 index 00000000000..35c2c9e22c2 --- /dev/null +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -0,0 +1,265 @@ +// Copyright (C) 2025 Stacks Open Internet Foundation +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! This module contains consensus tests related to Clarity CheckErrorKind errors that happens during contract initialization and execution. + +#[allow(unused_imports)] +use clarity::vm::analysis::CheckErrorKind; +use clarity::vm::types::MAX_TYPE_DEPTH; +use clarity::vm::Value as ClarityValue; + +use crate::chainstate::tests::consensus::{ + contract_call_consensus_test, contract_deploy_consensus_test, +}; +use crate::core::BLOCK_LIMIT_MAINNET_21; + +// CheckError: [`CheckErrorKind::CostBalanceExceeded`] +// Caused by: exceeding the cost analysis budget during contract initialization. +// The contract repeatedly performs `var-get` lookups on a data variable, +// forcing the type checker to fetch the variable enough times to exceed +// the read-count limit in [`BLOCK_LIMIT_MAINNET_21`]. +// Outcome: block rejected. +#[test] +fn check_error_cost_balance_exceeded() { + contract_deploy_consensus_test!( + contract_name: "cost-balance-exceeded", + contract_code: &format!(" + (define-data-var foo int 1) + (begin + {} + )", + "(var-get foo)\n".repeat(BLOCK_LIMIT_MAINNET_21.read_count as usize + 1) + ), + ); +} +// CheckError: [`CheckErrorKind::NameAlreadyUsed`] +// Caused by: name is already used by a standard clarity function. +// Outcome: block rejected. +#[test] +fn check_error_kind_name_already_used() { + contract_deploy_consensus_test!( + contract_name: "name-already-used", + contract_code: "(define-private (ft-get-supply) 1)", + ); +} +// CheckErrorKind: [`CheckErrorKind::ValueTooLarge`] +// Caused by: `(as-max-len? …)` wraps a buffer whose serialized size plus the optional wrapper +// exceeds `MAX_VALUE_SIZE`. Static analysis allows this construction, but initialization fails +// at runtime when `Value::some` detects the oversized payload. +// Outcome: block accepted. +#[test] +fn check_error_kind_value_too_large() { + contract_deploy_consensus_test!( + contract_name: "value-too-large", + contract_code: r#" + (define-private (make-buff-256) + (let ((b16 0x00112233445566778899aabbccddeeff) + (b32 (concat b16 b16)) + (b64 (concat b32 b32)) + (b128 (concat b64 b64)) + (b256 (concat b128 b128))) + b256)) + + (define-private (make-buff-4096) + (let ((b256 (make-buff-256)) + (b512 (concat b256 b256)) + (b1024 (concat b512 b512)) + (b2048 (concat b1024 b1024)) + (b4096 (concat b2048 b2048))) + b4096)) + + (define-private (make-buff-65536) + (let ((b4096 (make-buff-4096)) + (b8192 (concat b4096 b4096)) + (b16384 (concat b8192 b8192)) + (b32768 (concat b16384 b16384)) + (b65536 (concat b32768 b32768))) + b65536)) + + (define-private (make-buff-1048576) + (let ((b65536 (make-buff-65536)) + (b131072 (concat b65536 b65536)) + (b262144 (concat b131072 b131072)) + (b524288 (concat b262144 b262144)) + (b1048576 (concat b524288 b524288))) + b1048576)) + + (begin + (unwrap-panic (as-max-len? (make-buff-1048576) u1048576)) + u0) + "#, + ); +} + +// CheckErrorKind: [`CheckErrorKind::TypeSignatureTooDeep`] +// Caused by: inserting into a map whose value type already has depth `MAX_TYPE_DEPTH`. +// The runtime wraps stored entries in an optional, pushing the depth past the limit. +// Outcome: block accepted. +#[test] +fn check_error_kind_type_signature_too_deep() { + contract_deploy_consensus_test!( + contract_name: "type-depth-runtime", + contract_code: &{ + let optional_layers: usize = MAX_TYPE_DEPTH as usize - 2; + + let mut value_type = String::new(); + for _ in 0..optional_layers { + value_type.push_str("(optional "); + } + value_type.push_str("uint"); + for _ in 0..optional_layers { + value_type.push(')'); + } + + let mut let_bindings = String::from("(v0 u0)"); + for i in 1..=optional_layers { + let_bindings.push_str("\n "); + let_bindings.push_str(&format!("(v{i} (some v{}))", i - 1)); + } + let final_var = format!("v{optional_layers}"); + + format!( + "(define-map deep {{ key: uint }} {{ data: {value_type} }}) + (define-constant deep-value + (let ( + {let_bindings} + ) + {final_var})) + (begin + (map-insert deep (tuple (key u0)) (tuple (data deep-value))) + u0)" + ) + }, + ); +} + +// CheckErrorKind: [`CheckErrorKind::TypeValueError`] +// Caused by: passing a value of the wrong type to a function. +// Outcome: block accepted. +#[test] +fn check_error_kind_type_value_error_cdeploy() { + contract_deploy_consensus_test!( + contract_name: "check-error-kind", + contract_code: " + ;; `as-max-len?` widens `0x` to type `(buff 33)` even though it contains 0 bytes. + ;; This passes the analyzer but fails at runtime when `principal-of` enforces + ;; the exact length, raising `CheckErrorKind::TypeValueError`. + (principal-of? (unwrap-panic (as-max-len? 0x u33)))", + ); +} + +// pub enum CheckErrorKind { +// CostOverflow, // Unreachable: should exceed u64 +// CostBalanceExceeded(ExecutionCost, ExecutionCost), [`check_error_cost_balance_exceeded`] +// MemoryBalanceExceeded(u64, u64), +// CostComputationFailed(String), // Unreachable +// ExecutionTimeExpired, +// ValueTooLarge, [`check_error_kind_value_too_large`] +// ValueOutOfBounds, +// TypeSignatureTooDeep, [`check_error_kind_type_signature_too_deep`] +// ExpectedName, +// SupertypeTooLarge, +// Expects(String), +// BadMatchOptionSyntax(Box), +// BadMatchResponseSyntax(Box), +// BadMatchInput(Box), +// ListTypesMustMatch, +// TypeError(Box, Box), +// TypeValueError(Box, Box), [`check_error_kind_type_value_error_cdeploy`] +// InvalidTypeDescription, +// UnknownTypeName(String), +// UnionTypeError(Vec, Box), +// UnionTypeValueError(Vec, Box), +// ExpectedOptionalValue(Box), +// ExpectedResponseValue(Box), +// ExpectedOptionalOrResponseValue(Box), +// ExpectedContractPrincipalValue(Box), +// CouldNotDetermineType, +// BadTokenName, +// NoSuchNFT(String), +// NoSuchFT(String), +// BadTransferSTXArguments, +// BadTransferFTArguments, +// BadTransferNFTArguments, +// BadMintFTArguments, +// BadBurnFTArguments, +// ExpectedTuple(Box), +// NoSuchTupleField(String, TupleTypeSignature), +// EmptyTuplesNotAllowed, +// NoSuchDataVariable(String), +// NoSuchMap(String), +// DefineFunctionBadSignature, +// BadFunctionName, +// PublicFunctionMustReturnResponse(Box), +// ReturnTypesMustMatch(Box, Box), +// CircularReference(Vec), +// NoSuchContract(String), +// NoSuchPublicFunction(String, String), +// PublicFunctionNotReadOnly(String, String), +// ContractAlreadyExists(String), +// ContractCallExpectName, +// NoSuchBurnBlockInfoProperty(String), +// NoSuchStacksBlockInfoProperty(String), +// GetBlockInfoExpectPropertyName, +// GetStacksBlockInfoExpectPropertyName, +// GetTenureInfoExpectPropertyName, +// NameAlreadyUsed(String), +// NonFunctionApplication, +// ExpectedListApplication, +// ExpectedSequence(Box), +// BadLetSyntax, +// BadSyntaxBinding(SyntaxBindingError), +// UndefinedFunction(String), +// UndefinedVariable(String), +// RequiresAtLeastArguments(usize, usize), +// RequiresAtMostArguments(usize, usize), +// IncorrectArgumentCount(usize, usize), +// TooManyFunctionParameters(usize, usize), +// TraitReferenceUnknown(String), +// TraitMethodUnknown(String, String), +// ExpectedTraitIdentifier, +// BadTraitImplementation(String, String), +// DefineTraitBadSignature, +// DefineTraitDuplicateMethod(String), +// TraitBasedContractCallInReadOnly, +// ContractOfExpectsTrait, +// TraitTooManyMethods(usize, usize), +// InvalidCharactersDetected, +// InvalidUTF8Encoding, +// InvalidSecp65k1Signature, +// WriteAttemptedInReadOnly, +// AtBlockClosureMustBeReadOnly, +// ExpectedListOfAllowances(String, i32), +// AllowanceExprNotAllowed, +// ExpectedAllowanceExpr(String), +// WithAllAllowanceNotAllowed, +// WithAllAllowanceNotAlone, +// WithNftExpectedListOfIdentifiers, +// MaxIdentifierLengthExceeded(u32, u32), +// TooManyAllowances(usize, usize), +// } + +// CheckErrorKind: [`CheckErrorKind::TypeValueError`] +// Caused by: passing a value of the wrong type to a function. +// Outcome: block accepted. +#[test] +fn check_error_kind_type_value_error_ccall() { + contract_call_consensus_test!( + contract_name: "check-error-kind", + contract_code: "(define-public (trigger-error (x uint)) (ok true))", + function_name: "trigger-error", + function_args: &[ClarityValue::Bool(true)], + ); +} diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_value_error_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_value_error_ccall.snap new file mode 100644 index 00000000000..e093b50bd03 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_value_error_ccall.snap @@ -0,0 +1,1456 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "ed3f610a55927c7a7cbf7de6247d5fee574dd1d2b1df3285e90fd34b3baa3c7c", + evaluated_epoch: Epoch20, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_0-Clarity1, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 581000, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 581000, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "36468a56a9f9c2e5fb7fcf50af4d4d198f02f886b35d438a0fa2a1c59214bd75", + evaluated_epoch: Epoch2_05, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_05-Clarity1, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 305355, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 305355, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1902f6554741528182f212e3f4eba5fe48d6332dc5330406a8a776170e7ddf47", + evaluated_epoch: Epoch21, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_1-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e6997ee0d6a141d1b9bc77d56be7c358956e348f36515600034d984d67777ad0", + evaluated_epoch: Epoch21, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_1-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4869c503fa48a3c74301507338d69c94ba157600c6fe7003b9b44038a2398646", + evaluated_epoch: Epoch22, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "74eaf2e6572fec90af9d7af749bf80688ee44b2a99111ba26730829cdc6ecc02", + evaluated_epoch: Epoch22, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4e4df840e75ec41ff64cba4bd048f1683ab38c8c3584bc242aa3788a13761359", + evaluated_epoch: Epoch23, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "95fb45ce59195697b11688256f60fab976b8ac6c67e80ebf41ba1b0d4a8ac6d4", + evaluated_epoch: Epoch23, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4488bf9c0e904e0210834de6bf63141aad89b5ecb2ae2f2b8a312e5aa89489a3", + evaluated_epoch: Epoch24, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_4-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fa414551d7df575c2facd751704618d494dc068475f9f953e0ecdf75c3bddae3", + evaluated_epoch: Epoch24, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_4-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "641e05f12705974a90264813efc0dbf71617889f212b56cad4f286496aaa0731", + evaluated_epoch: Epoch25, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_5-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d5332f04a571b0fd6542ec979eecc3163163c9b6aed11dcc08b2f1091b12a2d2", + evaluated_epoch: Epoch25, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_5-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "08e12eb4cd65abc2655ee1541a772e31764f7c3ac0674931669cc24982db8ba3", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_0-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3289b1f436a2a18aa212a8ea6812ed331291020d257cbd0feea68f3a4904c9ce", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_0-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "88a7a979a02daa4f6bf956b66f7e359e8fbe772f0bc5a4959d6915a780431b68", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_0-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "165b64e1b47dc3d876835d4858f6b2526591184167fcc8f7644e942465b66291", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_1-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9a6453316f4cb5acb9651249adf7990e8c207a2fb1fa6d0ee17702b0ac2b2c6b", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_1-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f41cfc739aab1f23e4524aa15d573044eadad274f957e3b27b471f76031ca03f", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_1-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2958b6d3d3a9744f04ad08845fa80c0de83c8a817f753a89742fb63fa9f132ee", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "499d0c1032ffa2bc6dfb8959d126e6c806124ceb62c29adb15f410462cbfef33", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "72ad797f9a37d3ada890af7b614a14bf80947e80ca63db8bc17f2d6e8a0ccb15", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2e4fa556200c255e7c71a4c6a045406c3334f3dd9f35b5acf49abdf386347e40", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3636c1407ebc9a6465ae0d0c77c67a029729b905bcd4d1ed31fa24dc4b010ef9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6a368e403b287e6ec18eee21ee07ba255c533c78fcfafb505a6acd2cc20ed112", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5fdb4b0d435b03451a27f8078cde76fa8321c005985f7214b48d25cd6ffed1ba", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ca3686bae931eba40818795f692b3d6d1964a762d236d99d1fd4d305264b79bb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_0-Clarity1, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5f235469571b7a9d5fa029ea507499a59bee8848a2bbb6b01d6f594c20a5c0de", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_05-Clarity1, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2975cdebc05f02663e73b1c6708775f50d1701edae5c20048eb6d64141ec4f02", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_1-Clarity1, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b30beebaa39f77741ea970282cc6ac6fb75e262aa29aba6cbc1d86c32d49fef7", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_1-Clarity2, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8f16d1ca7b8a07ae5ab32b1a2efcc710c7a7cab34e34a76e7d24c2afc9f8943e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_2-Clarity1, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c450e44018e55bd111489da95ecf9222dc5862f2a7d43c384b07599200d77f03", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_2-Clarity2, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0d17a6437b1b176487dcc7acb621fca819535c065ffebe6bc488dd364cd73716", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_3-Clarity1, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "27d0f3c2daa02dc7c5ccf3581fe8cbed32a4cc893b78e1d20b1be97386039250", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_3-Clarity2, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b6172c9fac497ac0c3fec6e929665f33ef31e1afcf678ad40444c73b98307838", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_4-Clarity1, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ff5c3f74bffd7acbccd763aa3d875d9927663448240074c9d0e0355ea4172df5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_4-Clarity2, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2abbdb54575d119899fc60e0593ca0990dd38734f60059d5006c07fc2fdb8d55", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_5-Clarity1, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c231a21e13ab766e31567625d3984e41ddfd79fa8da5dd9119f1d91308e7b36e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_5-Clarity2, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ede9c0ec2b6714d165f80cca041562064bfb886291271cd1025049d94dc205bc", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_0-Clarity1, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c034a668e613f50b13d81e343e335090b667beb471ceac668bd8ac3f219440c8", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_0-Clarity2, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "78e76288d6f7c45358553adcfa98cc048c4bedf0e403d50dfa94651034c7cbed", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_0-Clarity3, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f26a215506cb97e2e904380adfdd79a313e4c47df95d376308ff5ca060dec343", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_1-Clarity1, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c75ae6a297311712e4bca1595f7ccc7458ed529630800cae0176c60f9a479086", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_1-Clarity2, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6912754dfda2daac6146a8f6d7987ea5a953c09b341633898989b08a3f9d7c0b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_1-Clarity3, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "06529c7916738977338fb3e02888c03f052925d38e82eaa8c4fb283f6f1d1496", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_2-Clarity1, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4185f7d9b2d5cbce6a7b60a6b0175195cd6db272b741edd22873f9ffe5316940", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_2-Clarity2, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d6a23d4c7134a91f41ae480baafd72ac731425f261ab7d9dfb229fabbf17132c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_2-Clarity3, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "63023e0ca7d5a7ec5637b55a48ac2cb6f18e2eb6c007feeb15f1f52b690ec9fd", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_3-Clarity1, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7bfb6cc9b24acd4224bc21de3cbeb4bf3d46c0f42696a4e2760c9ea730d28a2f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_3-Clarity2, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "33593cc783c9a74bafffc98d21cc9f1db96d59f2613a78f2585c9e9bafc46711", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_3-Clarity3, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "420a8154554ca90294f2c34737f3b1d3fddc7dc1165a1c3995e6f48ffbfb820d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_3-Clarity4, function_name: trigger-error, function_args: [[Bool(true)]])", + vm_error: "Some(TypeValueError(UIntType, Bool(true))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 168, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_value_error_cdeploy.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_value_error_cdeploy.snap new file mode 100644 index 00000000000..058aef15957 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_value_error_cdeploy.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "8e55538edd58262d81a0825d583fe73f3fe8a20674ef8c751adbad9fdf73e697", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(TypeValueError(SequenceType(BufferType(BufferLength(33))), Sequence(Buffer()))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 317, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 21506, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 317, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 21506, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "164f3c467022f4f202b9592f94a3e2fe9e26c7bc4296c311fc33f6b1fe6a7694", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(TypeValueError(SequenceType(BufferType(BufferLength(33))), Sequence(Buffer()))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 317, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 21505, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 317, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 21505, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f2d8ead5db5986df6aed58218d13f4574d3128f3a29af1fc9d62facfbc877214", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(TypeValueError(SequenceType(BufferType(BufferLength(33))), Sequence(Buffer()))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 317, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 21505, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 317, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 21505, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "cc3a620e6be240f0024700ca291296d7b963ad63844f0678479a9204f195b550", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(TypeValueError(SequenceType(BufferType(BufferLength(33))), Sequence(Buffer()))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 317, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 21505, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 317, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 21505, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_cost_balance_exceeded.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_cost_balance_exceeded.snap deleted file mode 100644 index a9bd31bb1f8..00000000000 --- a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_cost_balance_exceeded.snap +++ /dev/null @@ -1,22 +0,0 @@ ---- -source: stackslib/src/chainstate/tests/static_analysis_tests.rs -expression: result ---- -[ - Failure(ExpectedFailureOutput( - evaluated_epoch: Epoch33, - error: "Invalid Stacks block 04296a317858a65219360203bb34df7cc4e490d5b80e661ffa61d1d7f2b581f7: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135183501 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })", - )), - Failure(ExpectedFailureOutput( - evaluated_epoch: Epoch33, - error: "Invalid Stacks block 64bd21d5719a95afb9137237e44b0c54328e3a14b814c14e437fc89fe5244225: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135168502 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })", - )), - Failure(ExpectedFailureOutput( - evaluated_epoch: Epoch33, - error: "Invalid Stacks block b672c031d7a8fac0896f6c21e6fd911e580024a0ad0308a60dfd133a953576fa: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135168502 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })", - )), - Failure(ExpectedFailureOutput( - evaluated_epoch: Epoch33, - error: "Invalid Stacks block a8639c1bddd3a9aea58e3486249f0397686c727a1017580933539f2ff5844ec7: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135168502 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })", - )), -] From 8ab7c230bb7bcafeda8bef74a07009deac1b1530 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Tue, 18 Nov 2025 15:10:59 +0000 Subject: [PATCH 20/40] split calls and initialization check errors tests --- stackslib/src/chainstate/tests/runtime_analysis_tests.rs | 8 ++++---- ...tests__check_error_cost_balance_exceeded_cdeploy.snap} | 0 ...ests__check_error_kind_name_already_used_cdeploy.snap} | 0 ...check_error_kind_type_signature_too_deep_cdeploy.snap} | 0 ..._tests__check_error_kind_value_too_large_cdeploy.snap} | 0 5 files changed, 4 insertions(+), 4 deletions(-) rename stackslib/src/chainstate/tests/snapshots/{blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_cost_balance_exceeded.snap => blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_cost_balance_exceeded_cdeploy.snap} (100%) rename stackslib/src/chainstate/tests/snapshots/{blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used.snap => blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used_cdeploy.snap} (100%) rename stackslib/src/chainstate/tests/snapshots/{blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_signature_too_deep.snap => blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_signature_too_deep_cdeploy.snap} (100%) rename stackslib/src/chainstate/tests/snapshots/{blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_value_too_large.snap => blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_value_too_large_cdeploy.snap} (100%) diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index 35c2c9e22c2..5ef44fed8d5 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -32,7 +32,7 @@ use crate::core::BLOCK_LIMIT_MAINNET_21; // the read-count limit in [`BLOCK_LIMIT_MAINNET_21`]. // Outcome: block rejected. #[test] -fn check_error_cost_balance_exceeded() { +fn check_error_cost_balance_exceeded_cdeploy() { contract_deploy_consensus_test!( contract_name: "cost-balance-exceeded", contract_code: &format!(" @@ -48,7 +48,7 @@ fn check_error_cost_balance_exceeded() { // Caused by: name is already used by a standard clarity function. // Outcome: block rejected. #[test] -fn check_error_kind_name_already_used() { +fn check_error_kind_name_already_used_cdeploy() { contract_deploy_consensus_test!( contract_name: "name-already-used", contract_code: "(define-private (ft-get-supply) 1)", @@ -60,7 +60,7 @@ fn check_error_kind_name_already_used() { // at runtime when `Value::some` detects the oversized payload. // Outcome: block accepted. #[test] -fn check_error_kind_value_too_large() { +fn check_error_kind_value_too_large_cdeploy() { contract_deploy_consensus_test!( contract_name: "value-too-large", contract_code: r#" @@ -108,7 +108,7 @@ fn check_error_kind_value_too_large() { // The runtime wraps stored entries in an optional, pushing the depth past the limit. // Outcome: block accepted. #[test] -fn check_error_kind_type_signature_too_deep() { +fn check_error_kind_type_signature_too_deep_cdeploy() { contract_deploy_consensus_test!( contract_name: "type-depth-runtime", contract_code: &{ diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_cost_balance_exceeded.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_cost_balance_exceeded_cdeploy.snap similarity index 100% rename from stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_cost_balance_exceeded.snap rename to stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_cost_balance_exceeded_cdeploy.snap diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used_cdeploy.snap similarity index 100% rename from stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used.snap rename to stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used_cdeploy.snap diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_signature_too_deep.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_signature_too_deep_cdeploy.snap similarity index 100% rename from stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_signature_too_deep.snap rename to stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_signature_too_deep_cdeploy.snap diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_value_too_large.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_value_too_large_cdeploy.snap similarity index 100% rename from stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_value_too_large.snap rename to stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_value_too_large_cdeploy.snap From b21ad148d278c0afcfe9ffa8995789026aa37eed Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Wed, 19 Nov 2025 10:52:49 +0000 Subject: [PATCH 21/40] add setup_contracts to contract consensus_test macros --- stackslib/src/chainstate/tests/consensus.rs | 161 +++++++++++++++++--- 1 file changed, 137 insertions(+), 24 deletions(-) diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index 6a5c53b6183..f74e494508b 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -984,6 +984,8 @@ pub struct ContractConsensusTest<'a> { chain: ConsensusChain<'a>, /// Address of the contract deployer (the test faucet). contract_addr: StacksAddress, + /// Mapping of epoch → list of prerequisite contracts to deploy. + setup_contracts_per_epoch: HashMap>, /// Mapping of epoch → list of `(contract_name, ClarityVersion)` deployed in that epoch. /// Multiple versions may exist per epoch (e.g., Clarity 1, 2, 3 in Epoch 3.0). contract_deploys_per_epoch: HashMap>, @@ -1019,6 +1021,7 @@ impl ContractConsensusTest<'_> { /// * `contract_code` - Clarity source code of the contract /// * `function_name` - Contract function to test /// * `function_args` - Arguments passed to `function_name` on every call + /// * `setup_contracts` - Contracts that must be deployed before epoch-specific logic runs /// /// # Panics /// @@ -1034,6 +1037,7 @@ impl ContractConsensusTest<'_> { contract_code: &str, function_name: &str, function_args: &[ClarityValue], + setup_contracts: &[SetupContract], ) -> Self { assert!( !deploy_epochs.is_empty(), @@ -1051,15 +1055,48 @@ impl ContractConsensusTest<'_> { HashMap::new(); let mut contract_calls_per_epoch: HashMap> = HashMap::new(); let mut contract_names = vec![]; + let mut setup_contracts_per_epoch: HashMap> = + HashMap::new(); + + let mut epoch_candidates: BTreeSet = deploy_epochs.iter().copied().collect(); + epoch_candidates.extend(call_epochs.iter().copied()); + let default_setup_epoch = *epoch_candidates + .iter() + .next() + .expect("deploy_epochs guarantees at least one epoch"); + + for contract in setup_contracts { + // Deploy the setup contracts in the first epoch if not specified. + let deploy_epoch = contract.deploy_epoch.unwrap_or(default_setup_epoch); + // Get the default Clarity version for the epoch of the contract if not specified. + let clarity_version = contract.clarity_version.or_else(|| { + if deploy_epoch < StacksEpochId::Epoch21 { + None + } else { + Some(ClarityVersion::default_for_epoch(deploy_epoch)) + } + }); + let mut contract = contract.clone(); + contract.deploy_epoch = Some(deploy_epoch); + contract.clarity_version = clarity_version; + setup_contracts_per_epoch + .entry(deploy_epoch) + .or_default() + .push(contract); + } // Combine and sort unique epochs - let all_epochs: BTreeSet = - deploy_epochs.iter().chain(call_epochs).cloned().collect(); + let mut all_epochs: BTreeSet = epoch_candidates; + all_epochs.extend(setup_contracts_per_epoch.keys().copied()); // Precompute contract names and block counts for epoch in &all_epochs { let mut num_blocks = 0; + if let Some(contracts) = setup_contracts_per_epoch.get(epoch) { + num_blocks += contracts.len() as u64; + } + if deploy_epochs.contains(epoch) { let clarity_versions = clarity_versions_for_epoch(*epoch); let epoch_name = format!("Epoch{}", epoch.to_string().replace('.', "_")); @@ -1102,6 +1139,7 @@ impl ContractConsensusTest<'_> { contract_code: contract_code.to_string(), function_name: function_name.to_string(), function_args: function_args.to_vec(), + setup_contracts_per_epoch, all_epochs, } } @@ -1134,6 +1172,30 @@ impl ContractConsensusTest<'_> { result } + /// Deploys prerequisite contracts scheduled for the given epoch. + fn deploy_setup_contracts(&mut self, epoch: StacksEpochId) -> Vec { + let Some(contracts) = self.setup_contracts_per_epoch.get(&epoch).cloned() else { + return vec![]; + }; + + let is_naka_block = epoch.uses_nakamoto_blocks(); + contracts + .into_iter() + .map(|contract| { + self.chain.consume_pre_naka_prepare_phase(); + self.append_tx_block( + &TestTxSpec::ContractDeploy { + sender: &FAUCET_PRIV_KEY, + name: &contract.name, + code: &contract.code, + clarity_version: contract.clarity_version, + }, + is_naka_block, + ) + }) + .collect() + } + /// Deploys all contract versions scheduled for the given epoch. /// /// For each Clarity version supported in the epoch: @@ -1251,6 +1313,7 @@ impl ContractConsensusTest<'_> { .test_chainstate .advance_into_epoch(&private_key, epoch); + results.extend(self.deploy_setup_contracts(epoch)); results.extend(self.deploy_contracts(epoch)); results.extend(self.call_contracts(epoch)); } @@ -1464,8 +1527,9 @@ impl TestTxFactory { /// * `contract_code` — The Clarity source code for the contract. /// * `function_name` — The public function to call. /// * `function_args` — Function arguments, provided as a slice of [`ClarityValue`]. -/// * `deploy_epochs` — *(optional)* Epochs in which to deploy the contract. Defaults to all epochs ≥ 3.0. +/// * `deploy_epochs` — *(optional)* Epochs in which to deploy the contract. Defaults to all epochs ≥ 2.0. /// * `call_epochs` — *(optional)* Epochs in which to call the function. Defaults to [`EPOCHS_TO_TEST`]. +/// * `setup_contracts` — *(optional)* Slice of [`SetupContract`] values to deploy once before the main contract logic. /// /// # Example /// @@ -1474,9 +1538,15 @@ impl TestTxFactory { /// fn test_my_contract_call_consensus() { /// contract_call_consensus_test!( /// contract_name: "my-contract", -/// contract_code: "(define-public (get-message) (ok \"hello\"))", +/// contract_code: " +/// (define-public (get-message) +/// (contract-call? .dependency.foo))", /// function_name: "get-message", /// function_args: &[], +/// setup_contracts: &[SetupContract::new( +/// "dependency", +/// "(define-public (foo) (ok \"hello\"))", +/// )], /// ); /// } /// ``` @@ -1488,6 +1558,7 @@ macro_rules! contract_call_consensus_test { function_args: $function_args:expr, $(deploy_epochs: $deploy_epochs:expr,)? $(call_epochs: $call_epochs:expr,)? + $(setup_contracts: $setup_contracts:expr,)? ) => { { // Handle deploy_epochs parameter (default to all epochs >= 2.0 if not provided) @@ -1497,6 +1568,8 @@ macro_rules! contract_call_consensus_test { // Handle call_epochs parameter (default to EPOCHS_TO_TEST if not provided) let call_epochs = $crate::chainstate::tests::consensus::EPOCHS_TO_TEST; $(let call_epochs = $call_epochs;)? + let setup_contracts: &[$crate::chainstate::tests::consensus::SetupContract] = &[]; + $(let setup_contracts = $setup_contracts;)? let contract_test = $crate::chainstate::tests::consensus::ContractConsensusTest::new( function_name!(), vec![], @@ -1506,6 +1579,7 @@ macro_rules! contract_call_consensus_test { $contract_code, $function_name, $function_args, + setup_contracts, ); let result = contract_test.run(); insta::assert_ron_snapshot!(result); @@ -1532,6 +1606,7 @@ pub(crate) use contract_call_consensus_test; /// * `contract_name` — Name of the contract being tested. /// * `contract_code` — The Clarity source code of the contract. /// * `deploy_epochs` — *(optional)* Epochs in which to deploy the contract. Defaults to [`EPOCHS_TO_TEST`]. +/// * `setup_contracts` — *(optional)* Slice of [`SetupContract`] values to deploy before the main contract. /// /// # Example /// @@ -1546,34 +1621,72 @@ pub(crate) use contract_call_consensus_test; /// } /// ``` macro_rules! contract_deploy_consensus_test { - // Handle the case where deploy_epochs is not provided ( contract_name: $contract_name:expr, contract_code: $contract_code:expr, + $(deploy_epochs: $deploy_epochs:expr,)? + $(setup_contracts: $setup_contracts:expr,)? ) => { - contract_deploy_consensus_test!( - contract_name: $contract_name, - contract_code: $contract_code, - deploy_epochs: $crate::chainstate::tests::consensus::EPOCHS_TO_TEST, - ); - }; - ( - contract_name: $contract_name:expr, - contract_code: $contract_code:expr, - deploy_epochs: $deploy_epochs:expr, - ) => { - $crate::chainstate::tests::consensus::contract_call_consensus_test!( - contract_name: $contract_name, - contract_code: $contract_code, - function_name: "", // No function calls, just deploys - function_args: &[], // No function calls, just deploys - deploy_epochs: $deploy_epochs, - call_epochs: &[], // No function calls, just deploys - ); + { + let deploy_epochs = $crate::chainstate::tests::consensus::EPOCHS_TO_TEST; + $(let deploy_epochs = $deploy_epochs;)? + $crate::chainstate::tests::consensus::contract_call_consensus_test!( + contract_name: $contract_name, + contract_code: $contract_code, + function_name: "", // No function calls, just deploys + function_args: &[], // No function calls, just deploys + deploy_epochs: deploy_epochs, + call_epochs: &[], // No function calls, just deploys + $(setup_contracts: $setup_contracts,)? + ); + } }; } pub(crate) use contract_deploy_consensus_test; +/// Contract deployment that must occur before `contract_call_consensus_test!` or `contract_deploy_consensus_test!` runs its own logic. +/// +/// These setups are useful when the primary contract references other contracts (traits, functions, etc.) +/// that need to exist ahead of time with deterministic names and versions. +#[derive(Clone, Debug)] +pub struct SetupContract { + /// Contract name that should be deployed (no macro suffixes applied). + pub name: String, + /// Source code for the supporting contract. + pub code: String, + /// Optional Clarity version for this contract. + pub clarity_version: Option, + /// Optional epoch for this contract. + pub deploy_epoch: Option, +} + +impl SetupContract { + /// Creates a new SetupContract with default deployment settings. + /// + /// By default, the contract will deploy in the first epoch used by the test and with the + /// default Clarity version for that epoch. + pub fn new(name: impl Into, code: impl Into) -> Self { + Self { + name: name.into(), + code: code.into(), + clarity_version: None, + deploy_epoch: None, + } + } + + /// Override the epoch where this setup contract should deploy. + pub fn with_epoch(mut self, epoch: StacksEpochId) -> Self { + self.deploy_epoch = Some(epoch); + self + } + + /// Override the Clarity version used to deploy this setup contract. + pub fn with_clarity_version(mut self, version: ClarityVersion) -> Self { + self.clarity_version = Some(version); + self + } +} + // Just a namespace for utilities for writing consensus tests pub struct ConsensusUtils; From 7c6405345f8bdc22144bc25267a31e1767ff6d9a Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Wed, 19 Nov 2025 10:54:17 +0000 Subject: [PATCH 22/40] use setup_contracts for static_check_error_bad_trait_implementation --- .../chainstate/tests/static_analysis_tests.rs | 72 +++---------------- 1 file changed, 10 insertions(+), 62 deletions(-) diff --git a/stackslib/src/chainstate/tests/static_analysis_tests.rs b/stackslib/src/chainstate/tests/static_analysis_tests.rs index 628753363cf..98837249576 100644 --- a/stackslib/src/chainstate/tests/static_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/static_analysis_tests.rs @@ -1140,71 +1140,19 @@ fn static_check_error_get_tenure_info_expect_property_name() { // Outcome: block accepted. #[test] fn static_check_error_bad_trait_implementation() { - let contract_name = "contract-name"; - let contract_defining_trait = "(define-trait trait-1 ( - (get-1 ((list 10 uint)) (response uint uint))))"; - let impl_contract = format!( - "(impl-trait .{}.trait-1) - (define-public (get-1 (x (list 5 uint))) (ok u1))", - contract_name + let setup_contract = SetupContract::new( + "trait-contract", + "(define-trait trait-1 ((get-1 ((list 10 uint)) (response uint uint))))", ); - let mut nonce = 0; - - let tx_fee = (contract_defining_trait.len() * 100) as u64; - let mut epochs_blocks: HashMap> = HashMap::new(); - let deploy_tx = make_contract_publish_versioned( - &FAUCET_PRIV_KEY, - nonce, - tx_fee, - CHAIN_ID_TESTNET, - &contract_name, - &contract_defining_trait, - None, + contract_deploy_consensus_test!( + contract_name: "contract-name", + contract_code: &format!(" + (impl-trait .trait-contract.trait-1) + (define-public (get-1 (x (list 5 uint))) (ok u1))", + ), + setup_contracts: &[setup_contract], ); - nonce += 1; - epochs_blocks - .entry(*EPOCHS_TO_TEST.first().unwrap()) - .or_insert(vec![]) - .push(TestBlock { - transactions: vec![ - StacksTransaction::consensus_deserialize(&mut deploy_tx.as_slice()).unwrap(), - ], - }); - - for epoch in EPOCHS_TO_TEST { - for version in clarity_versions_for_epoch(*epoch) { - let epoch_name = format!("Epoch{}", epoch.to_string().replace(".", "_")); - let name = format!( - "{contract_name}-{epoch_name}-{}", - version.to_string().replace(" ", "") - ); - let deploy_tx = make_contract_publish_versioned( - &FAUCET_PRIV_KEY, - nonce, - tx_fee, - CHAIN_ID_TESTNET, - &name, - &impl_contract, - Some(*version), - ); - nonce += 1; - - let deploy_tx = - StacksTransaction::consensus_deserialize(&mut deploy_tx.as_slice()).unwrap(); - - let entry = epochs_blocks - .entry(*epoch) - .or_insert(vec![]) - .push(TestBlock { - transactions: vec![deploy_tx], - }); - } - } - - let result = ConsensusTest::new(function_name!(), vec![], epochs_blocks).run(); - - insta::assert_ron_snapshot!(result); } // Error: [`Error::InvalidStacksTransaction("Duplicate contract")`] From 881cf1db23967dfa540710497e9c157c9a7ba68e Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Wed, 19 Nov 2025 10:56:50 +0000 Subject: [PATCH 23/40] update docstrings for consensus tests --- .../tests/runtime_analysis_tests.rs | 48 +- .../chainstate/tests/static_analysis_tests.rs | 504 +++++++++--------- 2 files changed, 276 insertions(+), 276 deletions(-) diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index 5ef44fed8d5..9839f86f2ee 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -25,12 +25,12 @@ use crate::chainstate::tests::consensus::{ }; use crate::core::BLOCK_LIMIT_MAINNET_21; -// CheckError: [`CheckErrorKind::CostBalanceExceeded`] -// Caused by: exceeding the cost analysis budget during contract initialization. -// The contract repeatedly performs `var-get` lookups on a data variable, -// forcing the type checker to fetch the variable enough times to exceed -// the read-count limit in [`BLOCK_LIMIT_MAINNET_21`]. -// Outcome: block rejected. +/// CheckError: [`CheckErrorKind::CostBalanceExceeded`] +/// Caused by: exceeding the cost analysis budget during contract initialization. +/// The contract repeatedly performs `var-get` lookups on a data variable, +/// forcing the type checker to fetch the variable enough times to exceed +/// the read-count limit in [`BLOCK_LIMIT_MAINNET_21`]. +/// Outcome: block rejected. #[test] fn check_error_cost_balance_exceeded_cdeploy() { contract_deploy_consensus_test!( @@ -44,9 +44,9 @@ fn check_error_cost_balance_exceeded_cdeploy() { ), ); } -// CheckError: [`CheckErrorKind::NameAlreadyUsed`] -// Caused by: name is already used by a standard clarity function. -// Outcome: block rejected. +/// CheckError: [`CheckErrorKind::NameAlreadyUsed`] +/// Caused by: name is already used by a standard clarity function. +/// Outcome: block rejected. #[test] fn check_error_kind_name_already_used_cdeploy() { contract_deploy_consensus_test!( @@ -54,11 +54,11 @@ fn check_error_kind_name_already_used_cdeploy() { contract_code: "(define-private (ft-get-supply) 1)", ); } -// CheckErrorKind: [`CheckErrorKind::ValueTooLarge`] -// Caused by: `(as-max-len? …)` wraps a buffer whose serialized size plus the optional wrapper -// exceeds `MAX_VALUE_SIZE`. Static analysis allows this construction, but initialization fails -// at runtime when `Value::some` detects the oversized payload. -// Outcome: block accepted. +/// CheckErrorKind: [`CheckErrorKind::ValueTooLarge`] +/// Caused by: `(as-max-len? …)` wraps a buffer whose serialized size plus the optional wrapper +/// exceeds `MAX_VALUE_SIZE`. Static analysis allows this construction, but initialization fails +/// at runtime when `Value::some` detects the oversized payload. +/// Outcome: block accepted. #[test] fn check_error_kind_value_too_large_cdeploy() { contract_deploy_consensus_test!( @@ -103,10 +103,10 @@ fn check_error_kind_value_too_large_cdeploy() { ); } -// CheckErrorKind: [`CheckErrorKind::TypeSignatureTooDeep`] -// Caused by: inserting into a map whose value type already has depth `MAX_TYPE_DEPTH`. -// The runtime wraps stored entries in an optional, pushing the depth past the limit. -// Outcome: block accepted. +/// CheckErrorKind: [`CheckErrorKind::TypeSignatureTooDeep`] +/// Caused by: inserting into a map whose value type already has depth `MAX_TYPE_DEPTH`. +/// The runtime wraps stored entries in an optional, pushing the depth past the limit. +/// Outcome: block accepted. #[test] fn check_error_kind_type_signature_too_deep_cdeploy() { contract_deploy_consensus_test!( @@ -145,9 +145,9 @@ fn check_error_kind_type_signature_too_deep_cdeploy() { ); } -// CheckErrorKind: [`CheckErrorKind::TypeValueError`] -// Caused by: passing a value of the wrong type to a function. -// Outcome: block accepted. +/// CheckErrorKind: [`CheckErrorKind::TypeValueError`] +/// Caused by: passing a value of the wrong type to a function. +/// Outcome: block accepted. #[test] fn check_error_kind_type_value_error_cdeploy() { contract_deploy_consensus_test!( @@ -251,9 +251,9 @@ fn check_error_kind_type_value_error_cdeploy() { // TooManyAllowances(usize, usize), // } -// CheckErrorKind: [`CheckErrorKind::TypeValueError`] -// Caused by: passing a value of the wrong type to a function. -// Outcome: block accepted. +/// CheckErrorKind: [`CheckErrorKind::TypeValueError`] +/// Caused by: passing a value of the wrong type to a function. +/// Outcome: block accepted. #[test] fn check_error_kind_type_value_error_ccall() { contract_call_consensus_test!( diff --git a/stackslib/src/chainstate/tests/static_analysis_tests.rs b/stackslib/src/chainstate/tests/static_analysis_tests.rs index 98837249576..ca402a9bc80 100644 --- a/stackslib/src/chainstate/tests/static_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/static_analysis_tests.rs @@ -247,9 +247,9 @@ fn static_check_error_return_types_must_match() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::TypeError`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::TypeError`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_type_error() { contract_deploy_consensus_test!( @@ -258,9 +258,9 @@ fn static_check_error_type_error() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineVariableBadSignature`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineVariableBadSignature`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_define_variable_bad_signature() { contract_deploy_consensus_test!( @@ -269,9 +269,9 @@ fn static_check_error_define_variable_bad_signature() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::InvalidTypeDescription`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::InvalidTypeDescription`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_invalid_type_description() { contract_deploy_consensus_test!( @@ -280,9 +280,9 @@ fn static_check_error_invalid_type_description() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::TypeSignatureTooDeep`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::TypeSignatureTooDeep`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_type_signature_too_deep() { contract_deploy_consensus_test!( @@ -303,9 +303,9 @@ fn static_check_error_type_signature_too_deep() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::SupertypeTooLarge`] -// Caused by: -// Outcome: block rejected. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::SupertypeTooLarge`] +/// Caused by: +/// Outcome: block rejected. #[test] fn static_check_error_supertype_too_large() { contract_deploy_consensus_test!( @@ -319,9 +319,9 @@ fn static_check_error_supertype_too_large() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::ConstructedListTooLarge`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ConstructedListTooLarge`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_constructed_list_too_large() { contract_deploy_consensus_test!( @@ -336,12 +336,12 @@ fn static_check_error_constructed_list_too_large() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::UnknownTypeName`] -// Caused by: -// Outcome: block accepted. -// Note: during analysis, this error can only be triggered by `from-consensus-buff?` -// which is only available in Clarity 2 and later. So Clarity 1 will not trigger -// this error. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::UnknownTypeName`] +/// Caused by: +/// Outcome: block accepted. +/// Note: during analysis, this error can only be triggered by `from-consensus-buff?` +/// which is only available in Clarity 2 and later. So Clarity 1 will not trigger +/// this error. #[test] fn static_check_error_unknown_type_name() { contract_deploy_consensus_test!( @@ -352,9 +352,9 @@ fn static_check_error_unknown_type_name() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::UnionTypeError`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::UnionTypeError`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_union_type_error() { contract_deploy_consensus_test!( @@ -363,9 +363,9 @@ fn static_check_error_union_type_error() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::UndefinedVariable`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::UndefinedVariable`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_undefined_variable() { contract_deploy_consensus_test!( @@ -374,9 +374,9 @@ fn static_check_error_undefined_variable() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMapTypeDefinition`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMapTypeDefinition`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_bad_map_type_definition() { contract_deploy_consensus_test!( @@ -385,9 +385,9 @@ fn static_check_error_bad_map_type_definition() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineType`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineType`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_could_not_determine_type() { contract_deploy_consensus_test!( @@ -396,9 +396,9 @@ fn static_check_error_could_not_determine_type() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedSequence`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedSequence`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_expected_sequence() { contract_deploy_consensus_test!( @@ -407,12 +407,12 @@ fn static_check_error_expected_sequence() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineSerializationType`] -// Caused by: -// Outcome: block accepted. -// Note: during analysis, this error can only be triggered by `from-consensus-buff?` -// which is only available in Clarity 2 and later. So Clarity 1 will not trigger -// this error. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineSerializationType`] +/// Caused by: +/// Outcome: block accepted. +/// Note: during analysis, this error can only be triggered by `from-consensus-buff?` +/// which is only available in Clarity 2 and later. So Clarity 1 will not trigger +/// this error. #[test] fn static_check_error_could_not_determine_serialization_type() { contract_deploy_consensus_test!( @@ -425,9 +425,9 @@ fn static_check_error_could_not_determine_serialization_type() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::UncheckedIntermediaryResponses`] -// Caused by: Intermediate `(ok ...)` expressions inside a `begin` block that are not unwrapped. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::UncheckedIntermediaryResponses`] +/// Caused by: Intermediate `(ok ...)` expressions inside a `begin` block that are not unwrapped. +/// Outcome: block accepted. #[test] fn static_check_error_unchecked_intermediary_responses() { contract_deploy_consensus_test!( @@ -440,9 +440,9 @@ fn static_check_error_unchecked_intermediary_responses() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchFT`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchFT`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_no_such_ft() { contract_deploy_consensus_test!( @@ -451,9 +451,9 @@ fn static_check_error_no_such_ft() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchNFT`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchNFT`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_no_such_nft() { contract_deploy_consensus_test!( @@ -462,9 +462,9 @@ fn static_check_error_no_such_nft() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineNFTBadSignature`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineNFTBadSignature`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_define_nft_bad_signature() { contract_deploy_consensus_test!( @@ -473,9 +473,9 @@ fn static_check_error_define_nft_bad_signature() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTokenName`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTokenName`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_bad_token_name() { contract_deploy_consensus_test!( @@ -484,9 +484,9 @@ fn static_check_error_bad_token_name() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::EmptyTuplesNotAllowed`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::EmptyTuplesNotAllowed`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_empty_tuples_not_allowed() { contract_deploy_consensus_test!( @@ -497,9 +497,9 @@ fn static_check_error_empty_tuples_not_allowed() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchDataVariable`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchDataVariable`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_no_such_data_variable() { contract_deploy_consensus_test!( @@ -510,9 +510,9 @@ fn static_check_error_no_such_data_variable() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::NonFunctionApplication`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NonFunctionApplication`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_non_function_application() { contract_deploy_consensus_test!( @@ -521,9 +521,9 @@ fn static_check_error_non_function_application() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedListApplication`] -// Caused by: calling append with lhs that is not a list. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedListApplication`] +/// Caused by: calling append with lhs that is not a list. +/// Outcome: block accepted. #[test] fn static_check_error_expected_list_application() { contract_deploy_consensus_test!( @@ -532,9 +532,9 @@ fn static_check_error_expected_list_application() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchContract`] -// Caused by: calling contract-call? with a non-existent contract name. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchContract`] +/// Caused by: calling contract-call? with a non-existent contract name. +/// Outcome: block accepted. #[test] fn static_check_error_no_such_contract() { contract_deploy_consensus_test!( @@ -543,9 +543,9 @@ fn static_check_error_no_such_contract() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::ContractCallExpectName`] -// Caused by: calling contract-call? without a contract function name. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ContractCallExpectName`] +/// Caused by: calling contract-call? without a contract function name. +/// Outcome: block accepted. #[test] fn static_check_error_contract_call_expect_name() { contract_deploy_consensus_test!( @@ -554,10 +554,10 @@ fn static_check_error_contract_call_expect_name() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedCallableType`] -// Caused by: passing a non-callable constant as the contract principal in `contract-call?`. -// Outcome: block accepted. -// Note: This error was added in Clarity 2. Clarity 1 will trigger a [`StaticCheckErrorKind::TraitReferenceUnknown`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedCallableType`] +/// Caused by: passing a non-callable constant as the contract principal in `contract-call?`. +/// Outcome: block accepted. +/// Note: This error was added in Clarity 2. Clarity 1 will trigger a [`StaticCheckErrorKind::TraitReferenceUnknown`]. #[test] fn static_check_error_expected_callable_type() { contract_deploy_consensus_test!( @@ -569,9 +569,9 @@ fn static_check_error_expected_callable_type() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchPublicFunction`] -// Caused by: calling a non-existent public or read-only function on a contract literal. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchPublicFunction`] +/// Caused by: calling a non-existent public or read-only function on a contract literal. +/// Outcome: block accepted. #[test] fn static_check_error_no_such_public_function() { contract_deploy_consensus_test!( @@ -581,9 +581,9 @@ fn static_check_error_no_such_public_function() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::DefaultTypesMustMatch`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::DefaultTypesMustMatch`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_default_types_must_match() { contract_deploy_consensus_test!( @@ -594,9 +594,9 @@ fn static_check_error_default_types_must_match() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::IfArmsMustMatch`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::IfArmsMustMatch`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_if_arms_must_match() { contract_deploy_consensus_test!( @@ -605,9 +605,9 @@ fn static_check_error_if_arms_must_match() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::IllegalOrUnknownFunctionApplication`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::IllegalOrUnknownFunctionApplication`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_illegal_or_unknown_function_application() { contract_deploy_consensus_test!( @@ -616,9 +616,9 @@ fn static_check_error_illegal_or_unknown_function_application() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::UnknownFunction`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::UnknownFunction`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_unknown_function() { contract_deploy_consensus_test!( @@ -627,9 +627,9 @@ fn static_check_error_unknown_function() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::IncorrectArgumentCount`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::IncorrectArgumentCount`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_incorrect_argument_count() { contract_deploy_consensus_test!( @@ -638,9 +638,9 @@ fn static_check_error_incorrect_argument_count() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::BadLetSyntax`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadLetSyntax`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_bad_let_syntax() { contract_deploy_consensus_test!( @@ -649,9 +649,9 @@ fn static_check_error_bad_let_syntax() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::BadSyntaxBinding`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadSyntaxBinding`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_bad_syntax_binding() { contract_deploy_consensus_test!( @@ -660,9 +660,9 @@ fn static_check_error_bad_syntax_binding() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedOptionalOrResponseType`] -// Caused by: expected an optional or response type, but got a value -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedOptionalOrResponseType`] +/// Caused by: expected an optional or response type, but got a value +/// Outcome: block accepted. #[test] fn static_check_error_expected_optional_or_response_type() { contract_deploy_consensus_test!( @@ -671,9 +671,9 @@ fn static_check_error_expected_optional_or_response_type() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineTraitBadSignature`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineTraitBadSignature`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_define_trait_bad_signature() { contract_deploy_consensus_test!( @@ -682,10 +682,10 @@ fn static_check_error_define_trait_bad_signature() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineTraitDuplicateMethod`] -// Caused by: trait definition contains duplicate method names -// Outcome: block accepted. -// Note: This error was added in Clarity 2. Clarity 1 will accept the contract. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineTraitDuplicateMethod`] +/// Caused by: trait definition contains duplicate method names +/// Outcome: block accepted. +/// Note: This error was added in Clarity 2. Clarity 1 will accept the contract. #[test] fn static_check_error_define_trait_duplicate_method() { contract_deploy_consensus_test!( @@ -698,9 +698,9 @@ fn static_check_error_define_trait_duplicate_method() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::UnexpectedTraitOrFieldReference`] -// Caused by: unexpected use of trait reference or field -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::UnexpectedTraitOrFieldReference`] +/// Caused by: unexpected use of trait reference or field +/// Outcome: block accepted. #[test] fn static_check_error_unexpected_trait_or_field_reference() { contract_deploy_consensus_test!( @@ -709,10 +709,10 @@ fn static_check_error_unexpected_trait_or_field_reference() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::IncompatibleTrait`] -// Caused by: pass a trait to a trait parameter which is not compatible. -// Outcome: block accepted. -// Note: Added in Clarity 2. Clarity 1 will trigger a [`StaticCheckErrorKind::TypeError`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::IncompatibleTrait`] +/// Caused by: pass a trait to a trait parameter which is not compatible. +/// Outcome: block accepted. +/// Note: Added in Clarity 2. Clarity 1 will trigger a [`StaticCheckErrorKind::TypeError`]. #[test] fn static_check_error_incompatible_trait() { contract_deploy_consensus_test!( @@ -731,9 +731,9 @@ fn static_check_error_incompatible_trait() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::TraitTooManyMethods`] -// Caused by: a trait has too many methods. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::TraitTooManyMethods`] +/// Caused by: a trait has too many methods. +/// Outcome: block accepted. #[test] fn static_check_error_trait_too_many_methods() { contract_deploy_consensus_test!( @@ -748,9 +748,9 @@ fn static_check_error_trait_too_many_methods() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::TooManyFunctionParameters`] -// Caused by: a function has too many parameters. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::TooManyFunctionParameters`] +/// Caused by: a function has too many parameters. +/// Outcome: block accepted. #[test] fn static_check_error_too_many_function_parameters() { contract_deploy_consensus_test!( @@ -765,11 +765,11 @@ fn static_check_error_too_many_function_parameters() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::ReservedWord`] -// Caused by: name is a reserved word -// Outcome: block accepted. -// Note: This error was added in Clarity 3. Clarity 1 and 2 -// will trigger a [`CheckErrorKind::NameAlreadyUsed`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ReservedWord`] +/// Caused by: name is a reserved word +/// Outcome: block accepted. +/// Note: This error was added in Clarity 3. Clarity 1 and 2 +/// will trigger a [`CheckErrorKind::NameAlreadyUsed`]. #[test] fn static_check_error_reserved_word() { contract_deploy_consensus_test!( @@ -778,9 +778,9 @@ fn static_check_error_reserved_word() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchBlockInfoProperty`] -// Caused by: referenced an unknown property of a burn block -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchBlockInfoProperty`] +/// Caused by: referenced an unknown property of a burn block +/// Outcome: block accepted. #[test] fn static_check_error_no_such_block_info_property() { contract_deploy_consensus_test!( @@ -789,11 +789,11 @@ fn static_check_error_no_such_block_info_property() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchStacksBlockInfoProperty`] -// Caused by: referenced an unknown property of a stacks block -// Outcome: block accepted. -// Note: This error was added in Clarity 3. Clarity 1, and 2 -// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchStacksBlockInfoProperty`] +/// Caused by: referenced an unknown property of a stacks block +/// Outcome: block accepted. +/// Note: This error was added in Clarity 3. Clarity 1, and 2 +/// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_no_such_stacks_block_info_property() { contract_deploy_consensus_test!( @@ -802,11 +802,11 @@ fn static_check_error_no_such_stacks_block_info_property() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchTenureInfoProperty`] -// Caused by: referenced an unknown property of a tenure -// Outcome: block accepted. -// Note: This error was added in Clarity 3. Clarity 1, and 2 -// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchTenureInfoProperty`] +/// Caused by: referenced an unknown property of a tenure +/// Outcome: block accepted. +/// Note: This error was added in Clarity 3. Clarity 1, and 2 +/// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_no_such_tenure_info_property() { contract_deploy_consensus_test!( @@ -815,9 +815,9 @@ fn static_check_error_no_such_tenure_info_property() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::TraitReferenceUnknown`] -// Caused by: referenced trait is unknown -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::TraitReferenceUnknown`] +/// Caused by: referenced trait is unknown +/// Outcome: block accepted. #[test] fn static_check_error_trait_reference_unknown() { contract_deploy_consensus_test!( @@ -826,9 +826,9 @@ fn static_check_error_trait_reference_unknown() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::ContractOfExpectsTrait`] -// Caused by: calling `contract-of` with a non-trait argument. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ContractOfExpectsTrait`] +/// Caused by: calling `contract-of` with a non-trait argument. +/// Outcome: block accepted. #[test] fn static_check_error_contract_of_expects_trait() { contract_deploy_consensus_test!( @@ -837,9 +837,9 @@ fn static_check_error_contract_of_expects_trait() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::TraitMethodUnknown`] -// Caused by: defining a method that is not declared in the trait -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::TraitMethodUnknown`] +/// Caused by: defining a method that is not declared in the trait +/// Outcome: block accepted. #[test] fn static_check_error_trait_method_unknown() { contract_deploy_consensus_test!( @@ -852,9 +852,9 @@ fn static_check_error_trait_method_unknown() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::WriteAttemptedInReadOnly`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::WriteAttemptedInReadOnly`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_write_attempted_in_read_only() { contract_deploy_consensus_test!( @@ -866,9 +866,9 @@ fn static_check_error_write_attempted_in_read_only() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::AtBlockClosureMustBeReadOnly`] -// Caused by: `at-block` closure must be read-only but contains write operations. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::AtBlockClosureMustBeReadOnly`] +/// Caused by: `at-block` closure must be read-only but contains write operations. +/// Outcome: block accepted. #[test] fn static_check_error_at_block_closure_must_be_read_only() { contract_deploy_consensus_test!( @@ -881,11 +881,11 @@ fn static_check_error_at_block_closure_must_be_read_only() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::AllowanceExprNotAllowed`] -// Caused by: using an allowance expression outside of `restrict-assets?` or `as-contract?`. -// Outcome: block accepted. -// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 -// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::AllowanceExprNotAllowed`] +/// Caused by: using an allowance expression outside of `restrict-assets?` or `as-contract?`. +/// Outcome: block accepted. +/// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +/// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_allowance_expr_not_allowed() { contract_deploy_consensus_test!( @@ -894,11 +894,11 @@ fn static_check_error_allowance_expr_not_allowed() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedListOfAllowances`] -// Caused by: post-condition expects a list of asset allowances but received invalid input. -// Outcome: block accepted. -// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 -// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedListOfAllowances`] +/// Caused by: post-condition expects a list of asset allowances but received invalid input. +/// Outcome: block accepted. +/// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +/// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_expected_list_of_allowances() { contract_deploy_consensus_test!( @@ -907,11 +907,11 @@ fn static_check_error_expected_list_of_allowances() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedAllowanceExpr`] -// Caused by: allowance list contains a non-allowance expression. -// Outcome: block accepted. -// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 -// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedAllowanceExpr`] +/// Caused by: allowance list contains a non-allowance expression. +/// Outcome: block accepted. +/// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +/// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_expected_allowance_expr() { contract_deploy_consensus_test!( @@ -920,11 +920,11 @@ fn static_check_error_expected_allowance_expr() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::WithAllAllowanceNotAllowed`] -// Caused by: -// Outcome: block accepted. -// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 -// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::WithAllAllowanceNotAllowed`] +/// Caused by: +/// Outcome: block accepted. +/// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +/// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_with_all_allowance_not_allowed() { contract_deploy_consensus_test!( @@ -933,11 +933,11 @@ fn static_check_error_with_all_allowance_not_allowed() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::WithAllAllowanceNotAlone`] -// Caused by: -// Outcome: block accepted. -// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 -// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::WithAllAllowanceNotAlone`] +/// Caused by: +/// Outcome: block accepted. +/// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +/// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_with_all_allowance_not_alone() { contract_deploy_consensus_test!( @@ -946,11 +946,11 @@ fn static_check_error_with_all_allowance_not_alone() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::WithNftExpectedListOfIdentifiers`] -// Caused by: the third argument to `with-nft` is not a list of identifiers. -// Outcome: block accepted. -// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 -// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::WithNftExpectedListOfIdentifiers`] +/// Caused by: the third argument to `with-nft` is not a list of identifiers. +/// Outcome: block accepted. +/// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +/// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_with_nft_expected_list_of_identifiers() { contract_deploy_consensus_test!( @@ -959,11 +959,11 @@ fn static_check_error_with_nft_expected_list_of_identifiers() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::MaxIdentifierLengthExceeded`] -// Caused by: -// Outcome: block accepted. -// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 -// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::MaxIdentifierLengthExceeded`] +/// Caused by: +/// Outcome: block accepted. +/// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +/// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_max_identifier_length_exceeded() { contract_deploy_consensus_test!( @@ -977,11 +977,11 @@ fn static_check_error_max_identifier_length_exceeded() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::TooManyAllowances`] -// Caused by: -// Outcome: block accepted. -// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 -// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::TooManyAllowances`] +/// Caused by: +/// Outcome: block accepted. +/// Note: This error was added in Clarity 4. Clarity 1, 2, and 3 +/// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_too_many_allowances() { contract_deploy_consensus_test!( @@ -995,9 +995,9 @@ fn static_check_error_too_many_allowances() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTupleConstruction`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTupleConstruction`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_bad_tuple_construction() { contract_deploy_consensus_test!( @@ -1006,9 +1006,9 @@ fn static_check_error_bad_tuple_construction() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedTuple`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedTuple`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_expected_tuple() { contract_deploy_consensus_test!( @@ -1017,9 +1017,9 @@ fn static_check_error_expected_tuple() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchTupleField`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchTupleField`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_no_such_tuple_field() { contract_deploy_consensus_test!( @@ -1028,9 +1028,9 @@ fn static_check_error_no_such_tuple_field() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchMap`] -// Caused by: -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchMap`] +/// Caused by: +/// Outcome: block accepted. #[test] fn static_check_error_no_such_map() { contract_deploy_consensus_test!( @@ -1039,9 +1039,9 @@ fn static_check_error_no_such_map() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::BadFunctionName`] -// Caused by: defining a function whose signature does not start with an atom name. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadFunctionName`] +/// Caused by: defining a function whose signature does not start with an atom name. +/// Outcome: block accepted. #[test] fn static_check_error_bad_function_name() { contract_deploy_consensus_test!( @@ -1050,9 +1050,9 @@ fn static_check_error_bad_function_name() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineFunctionBadSignature`] -// Caused by: defining a function with an empty signature list. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineFunctionBadSignature`] +/// Caused by: defining a function with an empty signature list. +/// Outcome: block accepted. #[test] fn static_check_error_define_function_bad_signature() { contract_deploy_consensus_test!( @@ -1061,9 +1061,9 @@ fn static_check_error_define_function_bad_signature() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTupleFieldName`] -// Caused by: using `(get ...)` with a tuple field argument that is not an atom. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTupleFieldName`] +/// Caused by: using `(get ...)` with a tuple field argument that is not an atom. +/// Outcome: block accepted. #[test] fn static_check_error_bad_tuple_field_name() { contract_deploy_consensus_test!( @@ -1072,9 +1072,9 @@ fn static_check_error_bad_tuple_field_name() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMapName`] -// Caused by: passing a literal instead of a map identifier to `map-get?`. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMapName`] +/// Caused by: passing a literal instead of a map identifier to `map-get?`. +/// Outcome: block accepted. #[test] fn static_check_error_bad_map_name() { contract_deploy_consensus_test!( @@ -1083,11 +1083,11 @@ fn static_check_error_bad_map_name() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::GetBlockInfoExpectPropertyName`] -// Caused by: calling `get-block-info` with a non-atom property argument. -// Outcome: block accepted. -// Note: Only Clarity 1 and 2 will trigger this error. Clarity 3 and 4 -// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::GetBlockInfoExpectPropertyName`] +/// Caused by: calling `get-block-info` with a non-atom property argument. +/// Outcome: block accepted. +/// Note: Only Clarity 1 and 2 will trigger this error. Clarity 3 and 4 +/// will trigger a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_get_block_info_expect_property_name() { contract_deploy_consensus_test!( @@ -1096,11 +1096,11 @@ fn static_check_error_get_block_info_expect_property_name() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::GetBurnBlockInfoExpectPropertyName`] -// Caused by: calling `get-burn-block-info` with a non-atom property argument. -// Outcome: block accepted. -// Note: This error was added in Clarity 2. Clarity 1 will trigger -// a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::GetBurnBlockInfoExpectPropertyName`] +/// Caused by: calling `get-burn-block-info` with a non-atom property argument. +/// Outcome: block accepted. +/// Note: This error was added in Clarity 2. Clarity 1 will trigger +/// a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_get_burn_block_info_expect_property_name() { contract_deploy_consensus_test!( @@ -1109,11 +1109,11 @@ fn static_check_error_get_burn_block_info_expect_property_name() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::GetStacksBlockInfoExpectPropertyName`] -// Caused by: calling `get-stacks-block-info` with a non-atom property argument. -// Outcome: block accepted. -// Note: This error was added in Clarity 3. Clarity 1 and 2 will trigger -// a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::GetStacksBlockInfoExpectPropertyName`] +/// Caused by: calling `get-stacks-block-info` with a non-atom property argument. +/// Outcome: block accepted. +/// Note: This error was added in Clarity 3. Clarity 1 and 2 will trigger +/// a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_get_stacks_block_info_expect_property_name() { contract_deploy_consensus_test!( @@ -1122,11 +1122,11 @@ fn static_check_error_get_stacks_block_info_expect_property_name() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::GetTenureInfoExpectPropertyName`] -// Caused by: calling `get-tenure-info` with a non-atom property argument. -// Outcome: block accepted. -// Note: This error was added in Clarity 3. Clarity 1 and 2 will trigger -// a [`StaticCheckErrorKind::UnknownFunction`]. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::GetTenureInfoExpectPropertyName`] +/// Caused by: calling `get-tenure-info` with a non-atom property argument. +/// Outcome: block accepted. +/// Note: This error was added in Clarity 3. Clarity 1 and 2 will trigger +/// a [`StaticCheckErrorKind::UnknownFunction`]. #[test] fn static_check_error_get_tenure_info_expect_property_name() { contract_deploy_consensus_test!( @@ -1135,9 +1135,9 @@ fn static_check_error_get_tenure_info_expect_property_name() { ); } -// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTraitImplementation`] -// Caused by: trying to implement a trait with a bad implementation. -// Outcome: block accepted. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTraitImplementation`] +/// Caused by: trying to implement a trait with a bad implementation. +/// Outcome: block accepted. #[test] fn static_check_error_bad_trait_implementation() { let setup_contract = SetupContract::new( @@ -1155,9 +1155,9 @@ fn static_check_error_bad_trait_implementation() { ); } -// Error: [`Error::InvalidStacksTransaction("Duplicate contract")`] -// Caused by: trying to deploy a contract that already exists. -// Outcome: block rejected. +/// Error: [`Error::InvalidStacksTransaction("Duplicate contract")`] +/// Caused by: trying to deploy a contract that already exists. +/// Outcome: block rejected. #[test] fn error_invalid_stacks_transaction_duplicate_contract() { let contract_code = "(define-constant buff-0 0x00)"; From da7c9980b745505e1333ef7a829344c1d9448328 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Wed, 19 Nov 2025 11:51:05 +0000 Subject: [PATCH 24/40] add new tests --- clarity-types/src/errors/analysis.rs | 1 + .../tests/runtime_analysis_tests.rs | 78 +- ..._kind_contract_call_expect_name_ccall.snap | 296 ++++ ...r_kind_incorrect_argument_count_ccall.snap | 1456 +++++++++++++++++ ..._check_error_bad_trait_implementation.snap | 36 +- .../chainstate/tests/static_analysis_tests.rs | 4 +- 6 files changed, 1841 insertions(+), 30 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_ccall.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_incorrect_argument_count_ccall.snap diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index 6c331e4896e..7fc5d65f635 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -816,6 +816,7 @@ pub enum CheckErrorKind { /// The first `String` wraps the trait name, and the second wraps the method name. TraitMethodUnknown(String, String), /// Expected a trait identifier (e.g., `.trait-name`) but found an invalid token. + /// Unreachable: callable trait values always carry their trait id after sanitization ExpectedTraitIdentifier, /// Invalid implementation of a trait method. /// The first `String` wraps the trait name, and the second wraps the method name. diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index 9839f86f2ee..878ef17ef30 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -21,8 +21,10 @@ use clarity::vm::types::MAX_TYPE_DEPTH; use clarity::vm::Value as ClarityValue; use crate::chainstate::tests::consensus::{ - contract_call_consensus_test, contract_deploy_consensus_test, + contract_call_consensus_test, contract_deploy_consensus_test, SetupContract, EPOCHS_TO_TEST, + FAUCET_PRIV_KEY, }; +use crate::core::test_util::to_addr; use crate::core::BLOCK_LIMIT_MAINNET_21; /// CheckError: [`CheckErrorKind::CostBalanceExceeded`] @@ -162,16 +164,16 @@ fn check_error_kind_type_value_error_cdeploy() { // pub enum CheckErrorKind { // CostOverflow, // Unreachable: should exceed u64 -// CostBalanceExceeded(ExecutionCost, ExecutionCost), [`check_error_cost_balance_exceeded`] +// CostBalanceExceeded(ExecutionCost, ExecutionCost), [`check_error_cost_balance_exceeded_cdeploy`] // MemoryBalanceExceeded(u64, u64), // CostComputationFailed(String), // Unreachable // ExecutionTimeExpired, -// ValueTooLarge, [`check_error_kind_value_too_large`] -// ValueOutOfBounds, -// TypeSignatureTooDeep, [`check_error_kind_type_signature_too_deep`] -// ExpectedName, +// ValueTooLarge, [`check_error_kind_value_too_large_cdeploy`] +// ValueOutOfBounds, // Unreachable: validated before reaching the runtime error +// TypeSignatureTooDeep, [`check_error_kind_type_signature_too_deep_cdeploy`] +// ExpectedName, // Unreachable: every place in the runtime where ExpectedName is raised comes from a direct call to SymbolicExpression::match_atom() on the original AST node and the type checker runs the same structure check during analysis. // SupertypeTooLarge, -// Expects(String), +// Expects(String), // unreachable // BadMatchOptionSyntax(Box), // BadMatchResponseSyntax(Box), // BadMatchInput(Box), @@ -215,7 +217,7 @@ fn check_error_kind_type_value_error_cdeploy() { // GetBlockInfoExpectPropertyName, // GetStacksBlockInfoExpectPropertyName, // GetTenureInfoExpectPropertyName, -// NameAlreadyUsed(String), +// NameAlreadyUsed(String), [`check_error_kind_name_already_used_cdeploy`] // NonFunctionApplication, // ExpectedListApplication, // ExpectedSequence(Box), @@ -225,11 +227,11 @@ fn check_error_kind_type_value_error_cdeploy() { // UndefinedVariable(String), // RequiresAtLeastArguments(usize, usize), // RequiresAtMostArguments(usize, usize), -// IncorrectArgumentCount(usize, usize), +// IncorrectArgumentCount(usize, usize), [`check_error_kind_incorrect_argument_count_ccall`] // TooManyFunctionParameters(usize, usize), // TraitReferenceUnknown(String), // TraitMethodUnknown(String, String), -// ExpectedTraitIdentifier, +// ExpectedTraitIdentifier, // Unreachable: callable trait values always carry their trait id after sanitization // BadTraitImplementation(String, String), // DefineTraitBadSignature, // DefineTraitDuplicateMethod(String), @@ -263,3 +265,59 @@ fn check_error_kind_type_value_error_ccall() { function_args: &[ClarityValue::Bool(true)], ); } + +/// CheckErrorKind: [`CheckErrorKind::IncorrectArgumentCount`] +/// Caused by: passing the wrong number of arguments to a function. +/// Outcome: block accepted. +#[test] +fn check_error_kind_incorrect_argument_count_ccall() { + contract_call_consensus_test!( + contract_name: "check-error-kind", + contract_code: "(define-public (trigger-error (x uint)) (ok true))", + function_name: "trigger-error", + function_args: &[ClarityValue::Bool(true), ClarityValue::Bool(true)], + ); +} + +/// CheckErrorKind: [`CheckErrorKind::ContractCallExpectName`] +/// Caused by: the trait reference is stored as a constant, so the runtime never +/// binds it in `LocalContext::callable_contracts` and `special_contract_call` +/// cannot resolve the callee. +/// Outcome: block accepted. +/// Note: This test only works for Clarity 2 and later. +/// Clarity 1 will not be able to upload contract-3. +#[test] +fn check_error_kind_contract_call_expect_name_ccall() { + let contract_1 = SetupContract::new( + "contract-1", + "(define-trait simple-trait ( + (ping () (response bool uint))))", + ); + + let contract_2 = SetupContract::new( + "contract-2", + "(impl-trait .contract-1.simple-trait) + (define-public (ping) + (ok true))", + ); + + contract_call_consensus_test!( + contract_name: "contract-3", + contract_code: &format!( + " + (use-trait simple-trait .contract-1.simple-trait) + + ;; Trait reference stored as a constant. + (define-constant default-target '{}.contract-2) + + (define-public (trigger-error) + (contract-call? default-target ping))", + to_addr(&FAUCET_PRIV_KEY), + ), + function_name: "trigger-error", + function_args: &[], + deploy_epochs: EPOCHS_TO_TEST, + call_epochs: EPOCHS_TO_TEST, + setup_contracts: &[contract_1, contract_2], + ); +} diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_ccall.snap new file mode 100644 index 00000000000..4c585152f20 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_ccall.snap @@ -0,0 +1,296 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "0ed413e65d779028e446a5084abe41dfe99942dda9007a11ce59ee159199d25b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-1, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 86, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 10282, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 86, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 10282, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1f30d68d4acc5dd76b1339826c5c2e250fd6e407ca7a722d66380421a6a307d9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-2, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 103, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 11212, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 103, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 11212, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bb6dd7e3caa6503a5be1ae4ca5eeac6c4b699e83dc0f4b4329dce6072ba8a402", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of undeclared trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 5, + read_count: 2, + runtime: 8509, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 21, + write_count: 1, + read_length: 5, + read_count: 2, + runtime: 8509, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f572e132f368b52f6b8e94ff65d84d01d5eae91ba178e09ecc5bb93417d359c2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 295, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20724, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 295, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20724, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6ad91317b50a0d03310acafda9b377cee9d2b817d3605e0e96a51a6aa4bf1497", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 295, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20724, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 295, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20724, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "83e0f96934db11fe510a13e61c6852f446acd038b9559266e4eb3dac9d6d6ba4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 295, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20724, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 295, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20724, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "99dd71c6488ddcd3e733430bf50b47d69247574fa946cd5e3ae0dec0ea4d7afe", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: contract-3-Epoch3_3-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NoSuchContract(\"ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-3-Epoch3_3-Clarity1\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 0, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 0, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6cfdbaa75802d2c5d43c3f4a86934d4127bb67518ccb7c79c32a05f7a27ceaf8", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: contract-3-Epoch3_3-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(ContractCallExpectName) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 422, + read_count: 3, + runtime: 656, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 422, + read_count: 3, + runtime: 656, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9caf6f2aef5f239a157116e2a575a8d9e200ad9c91ea486c8bac6e20d855ad5a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: contract-3-Epoch3_3-Clarity3, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(ContractCallExpectName) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 422, + read_count: 3, + runtime: 656, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 422, + read_count: 3, + runtime: 656, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "96f015194f2bf6d725132ef1fbac105a781963673405717e41712a5e229fac18", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: contract-3-Epoch3_3-Clarity4, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(ContractCallExpectName) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 422, + read_count: 3, + runtime: 656, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 422, + read_count: 3, + runtime: 656, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_incorrect_argument_count_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_incorrect_argument_count_ccall.snap new file mode 100644 index 00000000000..b5ad291d6de --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_incorrect_argument_count_ccall.snap @@ -0,0 +1,1456 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "ed3f610a55927c7a7cbf7de6247d5fee574dd1d2b1df3285e90fd34b3baa3c7c", + evaluated_epoch: Epoch20, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_0-Clarity1, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 581000, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 581000, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "36468a56a9f9c2e5fb7fcf50af4d4d198f02f886b35d438a0fa2a1c59214bd75", + evaluated_epoch: Epoch2_05, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_05-Clarity1, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 305355, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 305355, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1902f6554741528182f212e3f4eba5fe48d6332dc5330406a8a776170e7ddf47", + evaluated_epoch: Epoch21, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_1-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e6997ee0d6a141d1b9bc77d56be7c358956e348f36515600034d984d67777ad0", + evaluated_epoch: Epoch21, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_1-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4869c503fa48a3c74301507338d69c94ba157600c6fe7003b9b44038a2398646", + evaluated_epoch: Epoch22, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "74eaf2e6572fec90af9d7af749bf80688ee44b2a99111ba26730829cdc6ecc02", + evaluated_epoch: Epoch22, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4e4df840e75ec41ff64cba4bd048f1683ab38c8c3584bc242aa3788a13761359", + evaluated_epoch: Epoch23, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "95fb45ce59195697b11688256f60fab976b8ac6c67e80ebf41ba1b0d4a8ac6d4", + evaluated_epoch: Epoch23, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4488bf9c0e904e0210834de6bf63141aad89b5ecb2ae2f2b8a312e5aa89489a3", + evaluated_epoch: Epoch24, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_4-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fa414551d7df575c2facd751704618d494dc068475f9f953e0ecdf75c3bddae3", + evaluated_epoch: Epoch24, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_4-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "641e05f12705974a90264813efc0dbf71617889f212b56cad4f286496aaa0731", + evaluated_epoch: Epoch25, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_5-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d5332f04a571b0fd6542ec979eecc3163163c9b6aed11dcc08b2f1091b12a2d2", + evaluated_epoch: Epoch25, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch2_5-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "08e12eb4cd65abc2655ee1541a772e31764f7c3ac0674931669cc24982db8ba3", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_0-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3289b1f436a2a18aa212a8ea6812ed331291020d257cbd0feea68f3a4904c9ce", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_0-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "88a7a979a02daa4f6bf956b66f7e359e8fbe772f0bc5a4959d6915a780431b68", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_0-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "165b64e1b47dc3d876835d4858f6b2526591184167fcc8f7644e942465b66291", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_1-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9a6453316f4cb5acb9651249adf7990e8c207a2fb1fa6d0ee17702b0ac2b2c6b", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_1-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f41cfc739aab1f23e4524aa15d573044eadad274f957e3b27b471f76031ca03f", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_1-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2958b6d3d3a9744f04ad08845fa80c0de83c8a817f753a89742fb63fa9f132ee", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "499d0c1032ffa2bc6dfb8959d126e6c806124ceb62c29adb15f410462cbfef33", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "72ad797f9a37d3ada890af7b614a14bf80947e80ca63db8bc17f2d6e8a0ccb15", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2e4fa556200c255e7c71a4c6a045406c3334f3dd9f35b5acf49abdf386347e40", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3636c1407ebc9a6465ae0d0c77c67a029729b905bcd4d1ed31fa24dc4b010ef9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6a368e403b287e6ec18eee21ee07ba255c533c78fcfafb505a6acd2cc20ed112", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5fdb4b0d435b03451a27f8078cde76fa8321c005985f7214b48d25cd6ffed1ba", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: check-error-kind-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9659, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ca3686bae931eba40818795f692b3d6d1964a762d236d99d1fd4d305264b79bb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_0-Clarity1, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ea5dae15acd89206e411242284862ea345b6792ae794c945e78cfaff74596283", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_05-Clarity1, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9d45771948d43057bad928f93af967efbc30c3de49f7699c811fa83fa38d1f95", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_1-Clarity1, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c5de01767c583e60213d407cdb82cf9f866a9739aac2b809685ce44d38b55d24", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_1-Clarity2, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f4c1c48c0ac15b53a66354e0bc914a775be57ab29e5c8a3f90b4bd14382cdc42", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_2-Clarity1, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "99564a4325638e3d4dd617e6e716272e6a6f88d2556faf85d4cc24ea65a050ad", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_2-Clarity2, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d3ae201f97af2f2c485adc26a731d78f5568a7bff821b71ccdaeb98328017d43", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_3-Clarity1, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a037247e6bae145436588b16ee1154cb6bfc6cad47705d3fe838a72c6663dd87", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_3-Clarity2, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c3759ad48dc4d9150a3ee3d85acbd39f31a49254c068256a524424cb8468c420", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_4-Clarity1, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "69001e47270b189071dd4e97a4324786d5a522d39496f5b8e2ec2d8ee99d989f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_4-Clarity2, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ff99c8d584b7a5c368e158bc902eb4cd09126a6a2031f7cd5d8909b01c80b58c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_5-Clarity1, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "29c3bf328b927260123982166c09794a8cc5cc3991655b3294539fb0b35c3152", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch2_5-Clarity2, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b4a686e72c7c4e4470eaaaca44b55b683b58dba42f1dc3dc0aa2609caefbe889", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_0-Clarity1, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e1f864bd98506ce34c7d388ab09b517029b1d9e899c0322cc87d9f87c7611c53", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_0-Clarity2, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "af7b42f0ed934c0bd68d99c8d5a51fa051456371e87ad70fa376a3a7b8589a9f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_0-Clarity3, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "31a32b47c4960f431fa6512a15594b01e42d5650b7ab2f7006f93b82c5a768b3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_1-Clarity1, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5c5325975f45c783a5cce9e3713b0e4a37897cc60484956b4332b70887891108", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_1-Clarity2, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "dfc23fc307bd7ee26fd40da58f85ee8e54032291587e2dba4e3cec98740f029a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_1-Clarity3, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f296e6b7074b8f7aaeef2060bed6645ad841be35b997b43685d0e63e47847116", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_2-Clarity1, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8780f00088fbe7772b115b1d73568ce05ffb03954566ff80a1f1e2cd0d2526fb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_2-Clarity2, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "602195690f42943d238c7ad31cb316df6bdcaa8b2f23b4a58fd15952a7a0e335", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_2-Clarity3, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c9c5e24e6f2357b9ac5d66ab1f7222324f276aea3c882a11fb506005f5bb21e7", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_3-Clarity1, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1716580b5e6e8f12676a0568a2c783693248d4acd3a610b56987119e4fc8b785", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_3-Clarity2, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "48a158bc5b8d8dad4cc452829235a5e5d892132a1f31a65d17aec2a6c68a9258", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_3-Clarity3, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f1c5474dad8123bde1a4a3aa6acd07abf072c07a1440ba09b5ef528586ddf007", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: check-error-kind-Epoch3_3-Clarity4, function_name: trigger-error, function_args: [[Bool(true), Bool(true)]])", + vm_error: "Some(IncorrectArgumentCount(1, 2)) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 51, + read_count: 3, + runtime: 175, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_trait_implementation.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_trait_implementation.snap index 89c5c649a51..fecbb5daa22 100644 --- a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_trait_implementation.snap +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_trait_implementation.snap @@ -4,35 +4,35 @@ expression: result --- [ Success(ExpectedBlockOutput( - marf_hash: "e6f830b4db97ad7c59cd9bd198805186ed1637062ce89d92f181ad4915c1ed77", + marf_hash: "ea4bd6655c60fab8f7361d5dadafe85828880fe8eedfcd1ee1009089d080c69a", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( - tx: "SmartContract(name: contract-name, code_body: [..], clarity_version: None)", + tx: "SmartContract(name: trait-contract, code_body: [..], clarity_version: Some(Clarity4))", vm_error: "None [NON-CONSENSUS BREAKING]", return_type: Response(ResponseData( committed: true, data: Bool(true), )), cost: ExecutionCost( - write_length: 96, + write_length: 87, write_count: 2, read_length: 1, read_count: 1, - runtime: 10532, + runtime: 10190, ), ), ], total_block_cost: ExecutionCost( - write_length: 96, + write_length: 87, write_count: 2, read_length: 1, read_count: 1, - runtime: 10532, + runtime: 10190, ), )), Success(ExpectedBlockOutput( - marf_hash: "8e74901492f6f7a162cd58fdef82553aef31fdf75aaa79b9e3cc274999c6e5eb", + marf_hash: "3e216b0c84ceed92b873d280c01a1541de4bc3fc8dea66968cd7af59387080e5", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -49,7 +49,7 @@ expression: result write_count: 1, read_length: 1, read_count: 1, - runtime: 2779, + runtime: 3373, ), ), ], @@ -58,11 +58,11 @@ expression: result write_count: 1, read_length: 1, read_count: 1, - runtime: 2779, + runtime: 3373, ), )), Success(ExpectedBlockOutput( - marf_hash: "aabef18709a4c5f1cdd41b577c0c4d8281c002f986f91b4c903679b3c0fe2646", + marf_hash: "53c830893cccd63de3eba2d50e763cf0e31166f51a97761352201aca2607caee", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -79,7 +79,7 @@ expression: result write_count: 1, read_length: 1, read_count: 1, - runtime: 2779, + runtime: 3373, ), ), ], @@ -88,11 +88,11 @@ expression: result write_count: 1, read_length: 1, read_count: 1, - runtime: 2779, + runtime: 3373, ), )), Success(ExpectedBlockOutput( - marf_hash: "9cd835d056818737970ca4a44a1bd97ec67bd2f5f33fc64c869754039fa16d17", + marf_hash: "fa6cc1f8cd406b2dc50bb654268085d7c62d89e775f756bec97cbcc3e70df447", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -109,7 +109,7 @@ expression: result write_count: 1, read_length: 1, read_count: 1, - runtime: 2779, + runtime: 3373, ), ), ], @@ -118,11 +118,11 @@ expression: result write_count: 1, read_length: 1, read_count: 1, - runtime: 2779, + runtime: 3373, ), )), Success(ExpectedBlockOutput( - marf_hash: "7086f00d0acbf060c348f204880859fcd6a9fe6ab5ca2f911a1369b9eedae353", + marf_hash: "b559f59ceb3fcd78971206e63bac42f5c3c7bd29ab001c21e1431d4fea0377fe", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -139,7 +139,7 @@ expression: result write_count: 1, read_length: 1, read_count: 1, - runtime: 2779, + runtime: 3373, ), ), ], @@ -148,7 +148,7 @@ expression: result write_count: 1, read_length: 1, read_count: 1, - runtime: 2779, + runtime: 3373, ), )), ] diff --git a/stackslib/src/chainstate/tests/static_analysis_tests.rs b/stackslib/src/chainstate/tests/static_analysis_tests.rs index ca402a9bc80..c5f588c6175 100644 --- a/stackslib/src/chainstate/tests/static_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/static_analysis_tests.rs @@ -27,8 +27,8 @@ use clarity::vm::types::MAX_TYPE_DEPTH; use crate::chainstate::stacks::StacksTransaction; use crate::chainstate::tests::consensus::{ - clarity_versions_for_epoch, contract_deploy_consensus_test, ConsensusTest, TestBlock, - EPOCHS_TO_TEST, FAUCET_PRIV_KEY, + clarity_versions_for_epoch, contract_deploy_consensus_test, ConsensusTest, SetupContract, + TestBlock, EPOCHS_TO_TEST, FAUCET_PRIV_KEY, }; use crate::core::test_util::make_contract_publish_versioned; use crate::core::BLOCK_LIMIT_MAINNET_21; From 153d672154cdf29f176e12800f58ae1073a680b2 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Wed, 19 Nov 2025 17:03:20 +0000 Subject: [PATCH 25/40] add tests --- .../tests/runtime_analysis_tests.rs | 81 +- ...ind_contract_call_expect_name_cdeploy.snap | 182 +++ ...ck_error_kind_name_already_used_ccall.snap | 1456 +++++++++++++++++ ...k_error_kind_undefined_function_ccall.snap | 1456 +++++++++++++++++ ...tic_check_error_cost_balance_exceeded.snap | 22 + ..._public_function_must_return_response.snap | 126 ++ .../chainstate/tests/static_analysis_tests.rs | 13 +- 7 files changed, 3331 insertions(+), 5 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_cdeploy.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used_ccall.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_undefined_function_ccall.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_cost_balance_exceeded.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_public_function_must_return_response.snap diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index 878ef17ef30..7363d12f334 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -27,7 +27,7 @@ use crate::chainstate::tests::consensus::{ use crate::core::test_util::to_addr; use crate::core::BLOCK_LIMIT_MAINNET_21; -/// CheckError: [`CheckErrorKind::CostBalanceExceeded`] +/// CheckErrorKind: [`CheckErrorKind::CostBalanceExceeded`] /// Caused by: exceeding the cost analysis budget during contract initialization. /// The contract repeatedly performs `var-get` lookups on a data variable, /// forcing the type checker to fetch the variable enough times to exceed @@ -46,7 +46,8 @@ fn check_error_cost_balance_exceeded_cdeploy() { ), ); } -/// CheckError: [`CheckErrorKind::NameAlreadyUsed`] + +/// CheckErrorKind: [`CheckErrorKind::NameAlreadyUsed`] /// Caused by: name is already used by a standard clarity function. /// Outcome: block rejected. #[test] @@ -56,6 +57,7 @@ fn check_error_kind_name_already_used_cdeploy() { contract_code: "(define-private (ft-get-supply) 1)", ); } + /// CheckErrorKind: [`CheckErrorKind::ValueTooLarge`] /// Caused by: `(as-max-len? …)` wraps a buffer whose serialized size plus the optional wrapper /// exceeds `MAX_VALUE_SIZE`. Static analysis allows this construction, but initialization fails @@ -162,6 +164,44 @@ fn check_error_kind_type_value_error_cdeploy() { ); } +/// CheckErrorKind: [`CheckErrorKind::ContractCallExpectName`] +/// Caused by: the trait reference is stored as a constant, so the runtime never +/// binds it in `LocalContext::callable_contracts` and `special_contract_call` +/// cannot resolve the callee. +/// Outcome: block accepted. +/// Note: This test only works for Clarity 2 and later. +/// Clarity 1 will not be able to upload contract-3. +#[test] +fn check_error_kind_contract_call_expect_name_cdeploy() { + let contract_1 = SetupContract::new( + "contract-1", + "(define-trait simple-trait ( + (ping () (response bool uint))))", + ); + + let contract_2 = SetupContract::new( + "contract-2", + "(impl-trait .contract-1.simple-trait) + (define-public (ping) + (ok true))", + ); + + contract_deploy_consensus_test!( + contract_name: "contract-3", + contract_code: &format!( + " + (use-trait simple-trait .contract-1.simple-trait) + + ;; Evaluated during initialization; runtime cannot resolve the callable. + (define-constant default-target '{}.contract-2) + + (contract-call? default-target ping)", + to_addr(&FAUCET_PRIV_KEY), + ), + setup_contracts: &[contract_1, contract_2], + ); +} + // pub enum CheckErrorKind { // CostOverflow, // Unreachable: should exceed u64 // CostBalanceExceeded(ExecutionCost, ExecutionCost), [`check_error_cost_balance_exceeded_cdeploy`] @@ -211,7 +251,7 @@ fn check_error_kind_type_value_error_cdeploy() { // NoSuchPublicFunction(String, String), // PublicFunctionNotReadOnly(String, String), // ContractAlreadyExists(String), -// ContractCallExpectName, +// ContractCallExpectName, [`check_error_kind_contract_call_expect_name_cdeploy`] // NoSuchBurnBlockInfoProperty(String), // NoSuchStacksBlockInfoProperty(String), // GetBlockInfoExpectPropertyName, @@ -223,7 +263,7 @@ fn check_error_kind_type_value_error_cdeploy() { // ExpectedSequence(Box), // BadLetSyntax, // BadSyntaxBinding(SyntaxBindingError), -// UndefinedFunction(String), +// UndefinedFunction(String), // Unreachable? Wasn't able to trigger this error during contract initialization. // UndefinedVariable(String), // RequiresAtLeastArguments(usize, usize), // RequiresAtMostArguments(usize, usize), @@ -321,3 +361,36 @@ fn check_error_kind_contract_call_expect_name_ccall() { setup_contracts: &[contract_1, contract_2], ); } + +/// CheckErrorKind: [`CheckErrorKind::NameAlreadyUsed`] +/// Caused by: a `let` binding attempts to shadow the reserved keyword `stacks-block-height`. +/// The analyzer accepts the contract, but binding happens only when the public +/// function executes, so the runtime raises `NameAlreadyUsed`. +/// Outcome: block accepted. +#[test] +fn check_error_kind_name_already_used_ccall() { + contract_call_consensus_test!( + contract_name: "name-already-used", + contract_code: " + (define-public (trigger-error) + (let ((ft-get-supply u0)) + (ok ft-get-supply)))", + function_name: "trigger-error", + function_args: &[], + ); +} + +/// CheckErrorKind: [`CheckErrorKind::UndefinedFunction`] +/// Caused by: invoking a public function name that is not defined in the contract. +/// Outcome: block accepted (transaction aborts with the runtime error). +#[test] +fn check_error_kind_undefined_function_ccall() { + contract_call_consensus_test!( + contract_name: "undef-fn-call", + contract_code: " + (define-public (noop) + (ok true))", + function_name: "missing-func", + function_args: &[], + ); +} diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_cdeploy.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_cdeploy.snap new file mode 100644 index 00000000000..3eddae86c5d --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_cdeploy.snap @@ -0,0 +1,182 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "0ed413e65d779028e446a5084abe41dfe99942dda9007a11ce59ee159199d25b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-1, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 86, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 10282, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 86, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 10282, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1f30d68d4acc5dd76b1339826c5c2e250fd6e407ca7a722d66380421a6a307d9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-2, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 103, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 11212, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 103, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 11212, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fa8b39ecda5b526d30a1c6a6bfa6e07314190f4dab63828fc80ab5c394e8623a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: use of undeclared trait ) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 5, + read_count: 2, + runtime: 8285, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 5, + read_count: 2, + runtime: 8285, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e90c914a105efe16dd0e8597057b2ada9c1cd9f2518977e0b893f4ae6b229e3f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(ContractCallExpectName) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 283, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20284, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 283, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20284, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9d87e24037bc57ce7fcdf895df5bf5b16e4f038712a86f5b00c678b1c5e74d54", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(ContractCallExpectName) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 283, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20284, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 283, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20284, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e636370df609897b28e1f05cd743600c92d7e4b4ed3a20eb4092bb0f83773368", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(ContractCallExpectName) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 283, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20284, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 283, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20284, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used_ccall.snap new file mode 100644 index 00000000000..69572bb6565 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used_ccall.snap @@ -0,0 +1,1456 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "f4e0d3a6e404cd12d01203d7147b2b3829289d41205f9970b84e3d18e59af349", + evaluated_epoch: Epoch20, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_0-Clarity1, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 1302000, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 1302000, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a57df37781c209efb537895f70ea1ce3526343ee1cb702fb6edbc449e4ddc960", + evaluated_epoch: Epoch2_05, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_05-Clarity1, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 317446, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 317446, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3d3c088b53b2fee517e82b5c9a75d5746cd3730ab8fb36ff2518d18298188060", + evaluated_epoch: Epoch21, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_1-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "11e2297b8bf54190aa919dd2c000b9c6c94aac9932caa3098fa2c8aacedec38a", + evaluated_epoch: Epoch21, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_1-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "318ded0ace5e713475f73575c25bbd559b983153a77dcb5112a97dde60e8bb98", + evaluated_epoch: Epoch22, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "650d1b2e5a75d2cf2444312f954f08b089796651d72fc25217f2608783b14842", + evaluated_epoch: Epoch22, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c357d4cb999d8fe308a5ae00a5f11ddcc185f5401b5db2d65fee83ac785da96c", + evaluated_epoch: Epoch23, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "febe896ea2c3b0a004b7493141df7dc1ac913adb24ca2691b51656ef9206b467", + evaluated_epoch: Epoch23, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8bc99f3d50a09e20b07d772236364e3df5101a266132ad87c8468de572777e40", + evaluated_epoch: Epoch24, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_4-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f371093f0f8aa0c9b0ba20a9940b7ec8d854695114c184b2dca944ae928aab33", + evaluated_epoch: Epoch24, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_4-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "134c208c7b0e0851c190e573bfb36cdaca1f0ad14217d94d7e2b2782471eeab1", + evaluated_epoch: Epoch25, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_5-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9e36ac749e3f62d7940d08383b005d162b9a9db1d14daedbff2619bfe2925d13", + evaluated_epoch: Epoch25, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch2_5-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fd3f7692e015812e5ede8ee718aef1ae4f4f61d11564a38a9769512ce371b00d", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_0-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "dbe69a5fd2485f13451e35194913e3ee254061bcc0eee09ee18fbd3b5df1fa80", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_0-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0287073a128c2221dae29de2b8b1438758c6a5cc9bbc6352dcfeed5e307a5ebb", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_0-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7e7638c4c2d4e0b215954d35ca343cfc40e4c81bcee3580bd7f7835f0753279c", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_1-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "31961995ee20500f5d3748b6769ffa97bdebeaf99fd7a5f93df339cba83555d3", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_1-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f5ead5e4b38baa33ed414ddd3f408ca41670e045148da6529698f750765b91ae", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_1-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "27b1b8239658500591e6e059fbf0e3575aa921e45f06eb40ff15777184f5c10c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "15a62e33a22ff8fb35091044cbf4e54780a216e3c133260c469f22005ce5bccb", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1d400dfe32efad8d6558b009fc4236b82dea9c6cda932787f153f53b2b1e0d74", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "843d10170314537c886ca8fa3695c568dea7046f8bd62f40453a36bfcc56be53", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c4447b62c70bfbec9c7c29044c006e943e0962c664388c3fc8c73c85571faded", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f860b425b0a24d052b25d6504eb6b0308b5775e2eba80ca314ece1fc00ffed25", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d5fafde0659ea6d7ca022db2ebaa43511d604414007283e0d31b1e36061382aa", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 129, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 12202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "58de320ee66487b81ee1a0b60657e9bb2518c9834a8478c183988c829336928a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_0-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "12163f02bdfcb39eed04bfd3db5742238203566f4ed7cbd9bc012b5c547ef71b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_05-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b136b9710eb4fb73d09ba61ffbe3d209518dd85b09702489255d103c1541638d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_1-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "181b3507d1497ba65ec047c728a7c515da5374df3452bcb0731755f9d3622fab", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_1-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "93d28c4bdef1ee09ed6604f042d424d7a835dbbce315ac5133c6d57a9e41acae", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_2-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9e727f35017a354bd7754efec998a6ece0b962beb2d90d9e219b820de911328c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_2-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "50ab151d51adc014337495c4b3cd5e217c285a59db06fdbb7f950b96e88f8389", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_3-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "409eea04f777264cfaca9b5f5eb5bdff6bc9c3d815ecffd559e584b5bb639558", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_3-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "43fe1d75da1c49d145845641316c165c279cf17c2a2de430081b2c63d7e54e0c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_4-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5c4565617b48310bb24a05b93744423a19b9b8f176db6681584da25a2ebee661", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_4-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5fd9b6cd8ef7829ba3b2a925557ef55091c03cbffba8c4c9937201ccc58426ee", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_5-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9351a0151549f164db995080252d6e1229fc2c145a58d0b3857df56ed5761527", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch2_5-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "882bffb1df6caa8c7a3ae1f4df69e07539091b7c136c6464a74dc6806f1f683e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_0-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "be1af4c976d0f75affc9fe6ed32e43df7a9c7d9b7bb3f3160d51b64f998ed419", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_0-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "390039c3020798e5da7656c8429bdde39d128c2951e203eb0b0cdb1afd041492", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_0-Clarity3, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9a37c53b6fe133e8e779aebbeeecf887fd43f7c82d16cad7a3b8d71968ac0511", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_1-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0493182ac6c3512d8458195cbe860a4a0bd50032bfc3dc770a395a9608357ec1", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_1-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a3224c68409954dea4b2883c93f0f06497af8f058f6b9d7caf26f1ca2260cce4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_1-Clarity3, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e09314de0c69c9b2d3c2e03823dd6ae53a4da5cfacd825cf73e8294a7563bec1", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_2-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c919a230104991bc1cdce07fd4f997c4e814a88318b51b0f08c67d95e871c372", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_2-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9d0d8c5dbea91e1a1dcbaeb3d6a5d887df6b027fb381796acccb280acd51d238", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_2-Clarity3, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1e00c29a0323b1f2d3c99defe6846deb46a887800e1e99d686d9d91e6f3f0617", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_3-Clarity1, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f1b3aa27b34c01e650f69b7cc3004e2174bed006abd3830cc703f5c6a6b4474f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_3-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "68288104dcf1f5dbea25a70231753b6ac2ac3589f4016522fdc2a3d9d038829e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_3-Clarity3, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8e9a4e6305582d6c8d53b1e6e4cc847b4218008e160fdf1abf0725cbb0b180e8", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: name-already-used-Epoch3_3-Clarity4, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(NameAlreadyUsed(\"ft-get-supply\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 115, + read_count: 3, + runtime: 510, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_undefined_function_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_undefined_function_ccall.snap new file mode 100644 index 00000000000..64f962d5326 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_undefined_function_ccall.snap @@ -0,0 +1,1456 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "0ab1bf6f7455a2e241c5eb01c7e25217e12c1ebeeaadba18a7913d6102adcd7e", + evaluated_epoch: Epoch20, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_0-Clarity1, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 609000, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 609000, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a763ec8b72977e0633f837b2bc353fb1c0cb1bb6e1986f283ad8704fc464c594", + evaluated_epoch: Epoch2_05, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_05-Clarity1, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 305897, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 305897, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6be1ccbbb04f18f533a94e66d70d79706ac81e482b56765274dd6afe68fbbf09", + evaluated_epoch: Epoch21, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_1-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b6dcb7b30687954419f13d807db87d0b821208bd5b592fd4f3a9c600708a797b", + evaluated_epoch: Epoch21, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_1-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "53bfdb1be3f33482b5ef4df587cdbc09d8cc6640ca9f2943b74ea4757cdd2302", + evaluated_epoch: Epoch22, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c0d8cfb95337826e8a87a62e7434caf5ada31ce1545c994d722a99344634b4c5", + evaluated_epoch: Epoch22, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0469d8ffc1af1d2f523b4c80cc4db61d27a563a3bc35b783a19469c8a25c106c", + evaluated_epoch: Epoch23, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ee2dc8b75fd4097889a7f4c00d0e50ef9e1e2fffa9c6cb6c4381e53f0323ce26", + evaluated_epoch: Epoch23, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9e52017615f665f8fe00b2fcfbb337441a7776d41ade41c8f7c9564f6ca7fe3f", + evaluated_epoch: Epoch24, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_4-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a9f97c4211ab7f24ac5804b1b1ecbc0e14a3af2aeb6d45c95269b802dfa5ecb1", + evaluated_epoch: Epoch24, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_4-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "db0c7233c7c4604a0038ca6c1a66f6891d2cdc04298ff91cdb116af95ead6f22", + evaluated_epoch: Epoch25, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_5-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1a2620ed6648f34c606fac45079d3fd78bd7c7efde8e9bc169298480daf347b8", + evaluated_epoch: Epoch25, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch2_5-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "9817ac1da15ee3f70c5734c10260f37e7f41513044017eafb0d8a622aed6cbf3", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_0-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "cb8cd107f79952fd0497f50bd9f3b6026fab8468062201577342adabe8cdcb1b", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_0-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4c9a1e7da89d1116fdf95fe7f75229ead79585cb795594d9b38120bf3c8bd482", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_0-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8aa5a1771479a7542a64d176afacd36863af679dba2e1e09ea89564900bdeb6a", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_1-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c7de4457e94319e76d2c571357479dde3eaef7a1a52ac688d85891dac8740515", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_1-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0cc97b6d9f32f5db30bb7c1c6bf1b6c463ac41298e290dd3d2edde3ad4492dc9", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_1-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a63247c9c4696088146a1b40a05b63805e02c2feb820ed721ed7a684a7a561d7", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "00395a682e1b1285f27d337209d302536db996d46ec941af90b7cc92625f1e3d", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "cc62900d2997aa95692aadc17674067ad656220698caa5dfa3d4174cf6b3fbe9", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fe5742a15cdb7b9a357832a17e5a66ea1d6c6f3c694d437d5304e5b04b184625", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "17e1240c643bb248aa4cbb3517d26bcfde4175ab4070a13753be6642ccaf1e69", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a8f91bfd3df3f42a886906061ac18a6918d8ca6e685fe98b079a6dd2352aef7b", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6afb7a5e5f272eacf26021c92ee1805a466f2ed974bdef55d936d233c89d16d5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: undef-fn-call-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 62, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9762, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4dea8cff72318fc8c1bd9d06407a50dec2c7ca2a7421c92837c2cf8e89de6fea", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_0-Clarity1, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "baa5fd16653076f752a83d24eb497ebba7def527aacefcaf5875fbc36cde0a68", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_05-Clarity1, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3c84befc4fd78cc92e1659ee7c311b65054adc0f093ac690aa796539ec7bbd94", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_1-Clarity1, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3abc676bfd39554d3460c1c0cb449ffa38c2ea929b21d500b13e26643798be7a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_1-Clarity2, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5ac5742cbe6181cc2ce5f4075d3f88d5fb22ad82758518b40e409aaa4998bef9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_2-Clarity1, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "0a53edc3e5f0f0d6d27898f142d761938ed717a2ac595dc8ff0e3e0bf4ba24c3", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_2-Clarity2, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e90429fe1e9b5cd15ae57935a68c489bd9e02ad88eb7495fb252c8e68677a9db", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_3-Clarity1, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "093ad943fcdbb8b75715664f0b2c637179c5a2f34dc093b6b7097a4afc5b52d2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_3-Clarity2, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d431383d46c31bfd572bae18db72b9c5cecfc5aa2ca1f022f291a9b7e3919411", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_4-Clarity1, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fa1ae4cc44b30bb33a1dcaac7e12242d58da9cb86ac032f2e12b6f467b13adae", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_4-Clarity2, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "580989dbe4f9e616511b6b8f4e821bf9055e64c3e3ca997ed7df2fc15000b2bb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_5-Clarity1, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c004545a92b38f9a90e26cb3afb7f9f75d71a2905168c95ce46ad5744d7d8605", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch2_5-Clarity2, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8a87274c316b1ee5dd20c4c9ee305e438b1731bab5ae377802c5810440915444", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_0-Clarity1, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "340ccec66b3715c267ef9c7138fe539749ce9d120923661a63b8765bf6d21ef5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_0-Clarity2, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e701acf4352c8f7e125e9e7b0af3301e961bbc2e5b39693a683356465482798a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_0-Clarity3, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b22ab43859f00770c13c1b141bcd7079b562a456b7daeb77bd8e7e78925e0473", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_1-Clarity1, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6d437664a178347f3bdf0856515041417f777fa1b1200f7f948f95646f429b9d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_1-Clarity2, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3cb0e6b19212b81c321e99a294986b8247c1faac112cb849920fed56bce21cf0", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_1-Clarity3, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "576ef250a10bf8b9d87642fca99694ae4b8f32fedccdea0295418fb8d9db3124", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_2-Clarity1, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "db26335fd69ef1c9e230d534405a35612db189ad4c9b35bed4314998578c0ad4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_2-Clarity2, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3ddd866d49d9fb652e19a19512518500a45bd134a48553f7fe8a30b21d5bf3ba", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_2-Clarity3, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bbc396ce4b94101c20941d24de308ef0509c9cdb547df5c7d87c8f0c54b0aaed", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_3-Clarity1, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d539afd10180f39e40f0b8ffb25e9b52ed1b6b1672667ba30b2c38a1dede355f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_3-Clarity2, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "941c5de5d614243874dc3458ff36049c75c6b26166a664cd3c3436af40c563cd", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_3-Clarity3, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "690a90456b63f2a27e5105562a364442ed516ecb0538868edb442dad4ad86c34", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: undef-fn-call-Epoch3_3-Clarity4, function_name: missing-func, function_args: [[]])", + vm_error: "Some(UndefinedFunction(\"missing-func\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 54, + read_count: 3, + runtime: 133, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_cost_balance_exceeded.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_cost_balance_exceeded.snap new file mode 100644 index 00000000000..a9bd31bb1f8 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_cost_balance_exceeded.snap @@ -0,0 +1,22 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Failure(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block 04296a317858a65219360203bb34df7cc4e490d5b80e661ffa61d1d7f2b581f7: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135183501 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })", + )), + Failure(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block 64bd21d5719a95afb9137237e44b0c54328e3a14b814c14e437fc89fe5244225: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135168502 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })", + )), + Failure(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block b672c031d7a8fac0896f6c21e6fd911e580024a0ad0308a60dfd133a953576fa: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135168502 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })", + )), + Failure(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block a8639c1bddd3a9aea58e3486249f0397686c727a1017580933539f2ff5844ec7: CostOverflowError(ExecutionCost { write_length: 0, write_count: 0, read_length: 0, read_count: 0, runtime: 0 }, ExecutionCost { write_length: 75013, write_count: 1, read_length: 1020001, read_count: 15001, runtime: 135168502 }, ExecutionCost { write_length: 15000000, write_count: 15000, read_length: 100000000, read_count: 15000, runtime: 5000000000 })", + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_public_function_must_return_response.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_public_function_must_return_response.snap new file mode 100644 index 00000000000..e4a94dfd6d8 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_public_function_must_return_response.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "ffa3b803b8f265d11fba465d54eccf469db85763d8f9158d759d670d18eb876a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: non-response-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "Some(:0:0: public functions must return an expression of type \'response\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2bfcb7eeedde001a27e5644f364850f9bb6681644591b1a8d27c5c0645a2e391", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: non-response-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(:0:0: public functions must return an expression of type \'response\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "cdbec54872e34bfc60228cd9be1338410b091c6a2763b2982581e880a55bd37c", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: non-response-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(:0:0: public functions must return an expression of type \'response\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7b212a20bd02b53803dfd87332e364c379039d94e237041512cb536275bc2c15", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: non-response-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(:0:0: public functions must return an expression of type \'response\', found \'bool\') [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 6, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 1288, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/static_analysis_tests.rs b/stackslib/src/chainstate/tests/static_analysis_tests.rs index c5f588c6175..59e9504fd4e 100644 --- a/stackslib/src/chainstate/tests/static_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/static_analysis_tests.rs @@ -352,6 +352,17 @@ fn static_check_error_unknown_type_name() { ); } +/// StaticCheckErrorKind: [`StaticCheckErrorKind::PublicFunctionMustReturnResponse`] +/// Caused by: defining a public function that does not return a response (ok or err). +/// Outcome: block accepted. +#[test] +fn static_check_error_public_function_must_return_response() { + contract_deploy_consensus_test!( + contract_name: "non-response", + contract_code: "(define-public (non-response) true)", + ); +} + /// StaticCheckErrorKind: [`StaticCheckErrorKind::UnionTypeError`] /// Caused by: /// Outcome: block accepted. @@ -1260,7 +1271,7 @@ fn error_invalid_stacks_transaction_duplicate_contract() { // DefineFunctionBadSignature, [`static_check_error_define_function_bad_signature`] // BadFunctionName, [`static_check_error_bad_function_name`] // BadMapTypeDefinition, [`static_check_error_bad_map_type_definition`] -// PublicFunctionMustReturnResponse(Box), +// PublicFunctionMustReturnResponse(Box), [`static_check_error_public_function_must_return_response`] // DefineVariableBadSignature, [`static_check_error_define_variable_bad_signature`] // ReturnTypesMustMatch(Box, Box), [`static_check_error_return_types_must_match`] // NoSuchContract(String), [`static_check_error_no_such_contract`] From d6a4b6527771f9fbb8757d25e0f700dd3f1e9ac4 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Wed, 19 Nov 2025 17:19:26 +0000 Subject: [PATCH 26/40] add check_error_kind_return_types_must_match_ccall --- .../tests/runtime_analysis_tests.rs | 37 +- ...or_kind_return_types_must_match_ccall.snap | 1512 +++++++++++++++++ 2 files changed, 1547 insertions(+), 2 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_return_types_must_match_ccall.snap diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index 7363d12f334..ba0a8c4c39e 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -17,7 +17,7 @@ #[allow(unused_imports)] use clarity::vm::analysis::CheckErrorKind; -use clarity::vm::types::MAX_TYPE_DEPTH; +use clarity::vm::types::{QualifiedContractIdentifier, MAX_TYPE_DEPTH}; use clarity::vm::Value as ClarityValue; use crate::chainstate::tests::consensus::{ @@ -245,7 +245,7 @@ fn check_error_kind_contract_call_expect_name_cdeploy() { // DefineFunctionBadSignature, // BadFunctionName, // PublicFunctionMustReturnResponse(Box), -// ReturnTypesMustMatch(Box, Box), +// ReturnTypesMustMatch(Box, Box), [`check_error_kind_return_types_must_match_ccall`] // CircularReference(Vec), // NoSuchContract(String), // NoSuchPublicFunction(String, String), @@ -394,3 +394,36 @@ fn check_error_kind_undefined_function_ccall() { function_args: &[], ); } + +/// CheckErrorKind: [`CheckErrorKind::ReturnTypesMustMatch`] +/// Caused by: dynamic dispatch through a trait argument returns a value whose type does not +/// conform to the trait specification. +/// Outcome: block accepted. +#[test] +fn check_error_kind_return_types_must_match_ccall() { + let trait_contract = SetupContract::new( + "trait-contract", + "(define-trait simple-trait ( + (get-1 (uint) (response uint uint))))", + ); + + let target_contract = + SetupContract::new("target-contract", "(define-public (get-1 (x uint)) (ok 1))"); + + let target_identifier = QualifiedContractIdentifier::parse(&format!( + "{}.target-contract", + to_addr(&FAUCET_PRIV_KEY) + )) + .unwrap(); + + contract_call_consensus_test!( + contract_name: "dispatching-contract", + contract_code: " + (use-trait simple-trait .trait-contract.simple-trait) + (define-public (wrapped-get-1 (contract )) + (contract-call? contract get-1 u0))", + function_name: "wrapped-get-1", + function_args: &[ClarityValue::from(target_identifier)], + setup_contracts: &[trait_contract, target_contract], + ); +} diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_return_types_must_match_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_return_types_must_match_ccall.snap new file mode 100644 index 00000000000..1602945ac2e --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_return_types_must_match_ccall.snap @@ -0,0 +1,1512 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "fa67646a603213a9add69073cbd13269dd6ac5041a1a0c58df477a7160b26b5a", + evaluated_epoch: Epoch20, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: trait-contract, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 92, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 883000, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 92, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 883000, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3d6b3e74abd9f9fc6264261509275f20abe00b71da8da5a13c4dccbd409bdaa9", + evaluated_epoch: Epoch20, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: target-contract, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 51, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 459000, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 51, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 459000, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6d29966d0b561d8434af4a76a31d324cafc83fd68fe61f26b445ba0285629dc8", + evaluated_epoch: Epoch20, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_0-Clarity1, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 1979000, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 1979000, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ce68d03e5ddf7e279fc0137d259a61ce1868fd54e36452c22132c2ee81406126", + evaluated_epoch: Epoch2_05, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_05-Clarity1, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 329721, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 329721, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "c7505c97c34e40526e6631a7146c2803c90347ca2b8dbf241c85caef445d7199", + evaluated_epoch: Epoch21, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_1-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4960acba07546102d64059e3c8229daa79727dce668330321b0cc9a30467b06b", + evaluated_epoch: Epoch21, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_1-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "866722f5a8449547998d2dc4c6f7cbc81d0bd3cfac33d84f58504a56c0be7c32", + evaluated_epoch: Epoch22, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a7233a1836bed895dbc077fd5ec57b95f3d2a58d88fe070eb6ebb3ded4696171", + evaluated_epoch: Epoch22, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "02087a97837bc13e5f69d030b778e601aeae134ccadf9a89bcd0adb5df628bea", + evaluated_epoch: Epoch23, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6e939af08c52610333aac6560e75a9c687b4825df63628d341a76b66a9876ad9", + evaluated_epoch: Epoch23, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5fbe7f1f54fc8da029d873eb1fcd610e7e9432a6e6071a55d10b129c77757bd0", + evaluated_epoch: Epoch24, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_4-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4bae187e97ea4be2a961d7d541d5b7562d0f8d721cb6b41f10d65c0f0a8c6a06", + evaluated_epoch: Epoch24, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_4-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d246f20e23fcdb779fd2519a6aaf1fcf8da3863d902d8570d84c131ef8912536", + evaluated_epoch: Epoch25, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_5-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4454ed9a3e8e5dbd6aff0ce41dabbf0cf05ce83a4b07f8a55b8141e14be374a7", + evaluated_epoch: Epoch25, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch2_5-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "cd83d8651be3b9787d6deaffc94309fcc7792930d3c581651ff1f1917c7c22cf", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_0-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f6f3f4b7b52586da9f983bf837170069015e2013a3c2c78950081f0e80aff0c2", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_0-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "cc9d00480100d03f4154475138c4b83d36aff945c5341736296954c5811ffd9f", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_0-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e109f68892573f274ebf04c4d805e432db391a946a75a5e45c70bd2b84d3edb2", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_1-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1037010c0c429d4aeeb40f89f2545045d7c865a2072e68a49c408f041bf75bae", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_1-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5bb97a0a3a90c4bc1494ae7ac9dcdbe81c81592e78b94309d4e3b266d1932de3", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_1-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ba3dc6100e2c3bae8236039ac8114b443e363333defb83cc3ad075de58116a9c", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_2-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6c223bdd937325f0a4b5668bdb22638ef1b9b87471e302e06c9a2547328a9df0", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_2-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "53b127e62476175d65c92ba6282f372cf947f1876f541f4dba2f264f28be1555", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_2-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "588264eca2dab1e4a8cabc5fe1ffa08a1b857d3d6b0db0e1b3ab4beb432c7024", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15501, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f82242403a6359dee89df5271368075dce8485ea8bf85b5533853b265c1d234d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "40ec6b9b3a3e67d79dfe405ae62c409a945e2b292f544e7ed4df60a2afa2eb96", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "358b03e56fe4223fe65cc79fc4adf9671a3bd0e6818c2247888bf4a8d1df56a1", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: dispatching-contract-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 198, + write_count: 2, + read_length: 6, + read_count: 2, + runtime: 15500, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "09a55714f1c553b2b118063f7eb03d1bfa8206a6a58571e26ae3989828bc6fab", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_0-Clarity1, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3d317dee7d525107e57f3722314a21ae378708dd724083cce958a6aa1854a63f", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_05-Clarity1, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d3f7f11dffbcff7b105bff31d5b5497aed3c2c1427d50336b79c20cfb0be5855", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_1-Clarity1, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "56ab638454f7de7406fcebd6dba33e20638ddc5f4444e42934252191a832e89a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_1-Clarity2, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "81a3d8800e48c53befe9a5882c298798186f5b29e69e4a7e4d22e1bd6b2bebbb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_2-Clarity1, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "411b6501dee6d673937cafeb5d36b64a54ed8e54adddcd405528f36a81149891", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_2-Clarity2, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "18070bc682e2538f089d187f34cb51ddb497a7260473ec940528e50421fb9a22", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_3-Clarity1, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f214f5d80f075867f1e7dbfea7d063f25e72b986576b96ad26ce3106f00b6668", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_3-Clarity2, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3de4f4e3bb25bd6f2ee8ee19a91710a4572c7fbf927ebd6472f9902ffe389a19", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_4-Clarity1, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1eeb9f0d3476a6543a7aeb2d47fe86298cc9f941340283c6b274dbd1516f15b5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_4-Clarity2, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "547be8ac65094859b58b495af983490133ef4c41e99371637df7a15a2a9a6504", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_5-Clarity1, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "2d155007584e04132126a2037d9fb3338b3acd54ff3cc5e82082cfd83617aa46", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch2_5-Clarity2, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "109e032fd7c2434e4f0c67ab3cc5b256b44eb2541601cfd0fd334957d858566a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_0-Clarity1, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "fb8977134c06543f575c9c7cfa143360eb63cdecf70e7aeb5b71cc00678471e9", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_0-Clarity2, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "d302c459083a147e349e38cb2126589dcf7dd7f9ba7dd86b57e6cd1c9db1d495", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_0-Clarity3, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "229e166911ccb9f427d67ae17dc45cd3a3d177a12c27f101c24bb8ba3e53b7f2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_1-Clarity1, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8420a6dd88355df92d8223e69ee5a12d673a2880140cefdc1426e4a05a22eace", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_1-Clarity2, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "94727636a33448261b28caaa876d4e88b2bbd4e077a5eb184aff71bbd3035441", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_1-Clarity3, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "25a95cb2798cc614604138d50ab8b58076d2c0df47512e1a7f14e780920f802e", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_2-Clarity1, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "5c9267d511d1a81aa8db5ff2e598fdb35b3ca072cf607b14bd7b6e1b05504dd7", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_2-Clarity2, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "68a053187b2a4f8d09129dfb49d46bde9ff856483c65ed584af6039f819c199d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_2-Clarity3, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e80d1d1cd3007ccdfacf6c2865e5eaf82363fdcc6c016b5ab0fded5281edebf4", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_3-Clarity1, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8df643a526c4418c25db06b1e072cdd0a2c5244b88bbc0da6dc1321d05eca8aa", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_3-Clarity2, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7c260ca14023d26ebf12fa7d37361d397b48b483e8d5b5128acc8b52b5fab5d8", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_3-Clarity3, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4d7b65a21dd7232130f149c576e3cf63ceda9045ba4dd198417a540307cb4872", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: dispatching-contract-Epoch3_3-Clarity4, function_name: wrapped-get-1, function_args: [[Principal(Contract(QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"target-contract\") }))]])", + vm_error: "Some(ReturnTypesMustMatch(ResponseType((UIntType, UIntType)), ResponseType((IntType, NoType)))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 216, + read_count: 6, + runtime: 1139, + ), + )), +] From da1029fe6fd77ad3eb87af81242cc7f5e81cfb96 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Thu, 20 Nov 2025 10:11:49 +0000 Subject: [PATCH 27/40] add check_error_kind_no_such_contract_ccall --- .../tests/runtime_analysis_tests.rs | 37 +++++++++++++++++-- ...eck_error_kind_no_such_contract_ccall.snap | 36 ++++++++++++++++++ 2 files changed, 70 insertions(+), 3 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_no_such_contract_ccall.snap diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index ba0a8c4c39e..413eeafc562 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -15,14 +15,16 @@ //! This module contains consensus tests related to Clarity CheckErrorKind errors that happens during contract initialization and execution. +use std::collections::HashMap; + #[allow(unused_imports)] use clarity::vm::analysis::CheckErrorKind; use clarity::vm::types::{QualifiedContractIdentifier, MAX_TYPE_DEPTH}; use clarity::vm::Value as ClarityValue; use crate::chainstate::tests::consensus::{ - contract_call_consensus_test, contract_deploy_consensus_test, SetupContract, EPOCHS_TO_TEST, - FAUCET_PRIV_KEY, + contract_call_consensus_test, contract_deploy_consensus_test, ConsensusTest, ConsensusUtils, + SetupContract, TestBlock, EPOCHS_TO_TEST, FAUCET_PRIV_KEY, }; use crate::core::test_util::to_addr; use crate::core::BLOCK_LIMIT_MAINNET_21; @@ -247,7 +249,7 @@ fn check_error_kind_contract_call_expect_name_cdeploy() { // PublicFunctionMustReturnResponse(Box), // ReturnTypesMustMatch(Box, Box), [`check_error_kind_return_types_must_match_ccall`] // CircularReference(Vec), -// NoSuchContract(String), +// NoSuchContract(String), [`check_error_kind_no_such_contract_ccall`] // NoSuchPublicFunction(String, String), // PublicFunctionNotReadOnly(String, String), // ContractAlreadyExists(String), @@ -427,3 +429,32 @@ fn check_error_kind_return_types_must_match_ccall() { setup_contracts: &[trait_contract, target_contract], ); } + +/// CheckErrorKind: [`CheckErrorKind::NoSuchContract`] +/// Caused by: calling a contract that does not exist. +/// Outcome: block accepted. +#[test] +fn check_error_kind_no_such_contract_ccall() { + let mut nonce = 0; + + let mut epochs_blocks = HashMap::new(); + + for epoch in EPOCHS_TO_TEST { + let call_tx = ConsensusUtils::new_call_tx( + nonce, + "non-existent-contract", + "this-function-does-not-exist", + ); + epochs_blocks + .entry(*epoch) + .or_insert(vec![]) + .push(TestBlock { + transactions: vec![call_tx], + }); + + nonce += 1; + } + + let result = ConsensusTest::new(function_name!(), vec![], epochs_blocks).run(); + insta::assert_ron_snapshot!(result); +} diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_no_such_contract_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_no_such_contract_ccall.snap new file mode 100644 index 00000000000..585272a2c27 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_no_such_contract_ccall.snap @@ -0,0 +1,36 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "0221a8b28a132a04a0a36c499529d642bf875c1ea6a8e3ccdbc2bc944e65fa5d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: non-existent-contract, function_name: this-function-does-not-exist, function_args: [[]])", + vm_error: "Some(NoSuchContract(\"ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.non-existent-contract\")) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 0, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 0, + read_count: 0, + runtime: 0, + ), + )), +] From 388a2f642b813b59f2b2ef3e539a4611eb72cfcb Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Fri, 21 Nov 2025 13:54:49 +0000 Subject: [PATCH 28/40] add optional clarity_versions parameter to contract consensus tests --- stackslib/src/chainstate/tests/consensus.rs | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index f74e494508b..cb81c558d46 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -1031,6 +1031,7 @@ impl ContractConsensusTest<'_> { pub fn new( test_name: &str, initial_balances: Vec<(PrincipalData, u64)>, + clarity_versions: &[ClarityVersion], deploy_epochs: &[StacksEpochId], call_epochs: &[StacksEpochId], contract_name: &str, @@ -1098,7 +1099,12 @@ impl ContractConsensusTest<'_> { } if deploy_epochs.contains(epoch) { - let clarity_versions = clarity_versions_for_epoch(*epoch); + let clarity_versions_per_epoch = clarity_versions_for_epoch(*epoch); + // Filter the clarity versions to only include the ones that are supported in the epoch. + let clarity_versions = clarity_versions + .iter() + .filter(|v| clarity_versions_per_epoch.contains(v)); + let epoch_name = format!("Epoch{}", epoch.to_string().replace('.', "_")); // Each deployment is a seperate TestBlock @@ -1558,6 +1564,7 @@ macro_rules! contract_call_consensus_test { function_args: $function_args:expr, $(deploy_epochs: $deploy_epochs:expr,)? $(call_epochs: $call_epochs:expr,)? + $(clarity_versions: $clarity_versions:expr,)? $(setup_contracts: $setup_contracts:expr,)? ) => { { @@ -1570,9 +1577,12 @@ macro_rules! contract_call_consensus_test { $(let call_epochs = $call_epochs;)? let setup_contracts: &[$crate::chainstate::tests::consensus::SetupContract] = &[]; $(let setup_contracts = $setup_contracts;)? + let clarity_versions = clarity::vm::ClarityVersion::ALL; + $(let clarity_versions = $clarity_versions;)? let contract_test = $crate::chainstate::tests::consensus::ContractConsensusTest::new( function_name!(), vec![], + clarity_versions, deploy_epochs, call_epochs, $contract_name, @@ -1625,6 +1635,7 @@ macro_rules! contract_deploy_consensus_test { contract_name: $contract_name:expr, contract_code: $contract_code:expr, $(deploy_epochs: $deploy_epochs:expr,)? + $(clarity_versions: $clarity_versions:expr,)? $(setup_contracts: $setup_contracts:expr,)? ) => { { @@ -1637,6 +1648,7 @@ macro_rules! contract_deploy_consensus_test { function_args: &[], // No function calls, just deploys deploy_epochs: deploy_epochs, call_epochs: &[], // No function calls, just deploys + $(clarity_versions: $clarity_versions,)? $(setup_contracts: $setup_contracts,)? ); } From 0a9d0f93e2aefae96c226199469da5a1bdaed3bd Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Fri, 21 Nov 2025 13:58:57 +0000 Subject: [PATCH 29/40] add consensus tests for CheckErrorKind::UnionTypeValueError --- .../tests/runtime_analysis_tests.rs | 62 ++++++++++++- ...ror_kind_union_type_value_error_ccall.snap | 92 +++++++++++++++++++ ...r_kind_union_type_value_error_cdeploy.snap | 64 +++++++++++++ 3 files changed, 217 insertions(+), 1 deletion(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_ccall.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_cdeploy.snap diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index 413eeafc562..e5e4087271c 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -20,7 +20,7 @@ use std::collections::HashMap; #[allow(unused_imports)] use clarity::vm::analysis::CheckErrorKind; use clarity::vm::types::{QualifiedContractIdentifier, MAX_TYPE_DEPTH}; -use clarity::vm::Value as ClarityValue; +use clarity::vm::{ClarityVersion, Value as ClarityValue}; use crate::chainstate::tests::consensus::{ contract_call_consensus_test, contract_deploy_consensus_test, ConsensusTest, ConsensusUtils, @@ -204,6 +204,35 @@ fn check_error_kind_contract_call_expect_name_cdeploy() { ); } +/// CheckErrorKind: [`CheckErrorKind::UnionTypeValueError`] +/// Caused by: +/// Outcome: block accepted. +/// Note: This test only works for Clarity 4 and later. +/// Clarity 1, 2, 3 will return a [`StaticCheckErrorKind::UnknownFunction`]. +#[test] +fn check_error_kind_union_type_value_error_cdeploy() { + let contract_1 = SetupContract::new( + "contract-1", + "(define-public (dummy) + (ok true))", + ); + + contract_deploy_consensus_test!( + contract_name: "contract-2", + contract_code: " + (define-trait trait-1 ( + (dummy () (response bool uint)))) + + (define-public (foo (contract )) + (to-ascii? contract)) + + (define-constant trigger-error + (foo .contract-1))", + clarity_versions: &[ClarityVersion::Clarity4], + setup_contracts: &[contract_1], + ); +} + // pub enum CheckErrorKind { // CostOverflow, // Unreachable: should exceed u64 // CostBalanceExceeded(ExecutionCost, ExecutionCost), [`check_error_cost_balance_exceeded_cdeploy`] @@ -458,3 +487,34 @@ fn check_error_kind_no_such_contract_ccall() { let result = ConsensusTest::new(function_name!(), vec![], epochs_blocks).run(); insta::assert_ron_snapshot!(result); } + +/// CheckErrorKind: [`CheckErrorKind::UnionTypeValueError`] +/// Caused by: +/// Outcome: block accepted. +/// Note: This test only works for Clarity 4 and later. +/// Clarity 1, 2, 3 will return a [`StaticCheckErrorKind::UnknownFunction`]. +#[test] +fn check_error_kind_union_type_value_error_ccall() { + let contract_1 = SetupContract::new( + "contract-1", + "(define-public (dummy) + (ok true))", + ); + + contract_call_consensus_test!( + contract_name: "contract-2", + contract_code: " + (define-trait trait-1 ( + (dummy () (response bool uint)))) + + (define-public (foo (contract )) + (to-ascii? contract)) + + (define-public (trigger-runtime-error) + (foo .contract-1))", + function_name: "trigger-runtime-error", + function_args: &[], + clarity_versions: &[ClarityVersion::Clarity4], + setup_contracts: &[contract_1], + ); +} diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_ccall.snap new file mode 100644 index 00000000000..7809c74be6b --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_ccall.snap @@ -0,0 +1,92 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "b9c8422f985da80d714ac47d9b547a9dce5877b510749b82e9e5bc90a36dd8c7", + evaluated_epoch: Epoch20, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-1, code_body: [..], clarity_version: None)", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 58, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 565000, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 58, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 565000, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "05142693c23e7aaf7bddb457b19e36e2990b4d0412cbe76b448bc5753a20b821", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-2-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 296, + write_count: 2, + read_length: 3, + read_count: 2, + runtime: 20202, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 296, + write_count: 2, + read_length: 3, + read_count: 2, + runtime: 20202, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8232aa03717c4a276de9cdedac5031274e925d8f49e7be54d0e0f7fb72f62c25", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: contract-2-Epoch3_3-Clarity4, function_name: trigger-runtime-error, function_args: [[]])", + vm_error: "Some(UnionTypeValueError([IntType, UIntType, BoolType, PrincipalType, SequenceType(BufferType(BufferLength(524284))), SequenceType(StringType(UTF8(StringUTF8Length(262144))))], CallableContract(CallableData { contract_identifier: QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"contract-1\") }, trait_identifier: Some(TraitIdentifier { name: ClarityName(\"trait-1\"), contract_identifier: QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"contract-2-Epoch3_3-Clarity4\") } }) }))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 267, + read_count: 3, + runtime: 5835, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 267, + read_count: 3, + runtime: 5835, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_cdeploy.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_cdeploy.snap new file mode 100644 index 00000000000..321bfe12e11 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_cdeploy.snap @@ -0,0 +1,64 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "fe901ae4720a11103c393c4d52fd3c488b65bad953b8de4effac4a60d9375421", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-1, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 58, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9610, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 58, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 9610, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "89d0625148d64e4c64add4eb0b6106cf68261e1221269d4ae818a5602def3252", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-2-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(UnionTypeValueError([IntType, UIntType, BoolType, PrincipalType, SequenceType(BufferType(BufferLength(524284))), SequenceType(StringType(UTF8(StringUTF8Length(262144))))], CallableContract(CallableData { contract_identifier: QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"contract-1\") }, trait_identifier: Some(TraitIdentifier { name: ClarityName(\"trait-1\"), contract_identifier: QualifiedContractIdentifier { issuer: StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP), name: ContractName(\"contract-2-Epoch3_3-Clarity4\") } }) }))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 287, + write_count: 2, + read_length: 3, + read_count: 2, + runtime: 25164, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 287, + write_count: 2, + read_length: 3, + read_count: 2, + runtime: 25164, + ), + )), +] From 770da986cc517db8652ddb42667ba1f00b17ab51 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Fri, 21 Nov 2025 13:59:39 +0000 Subject: [PATCH 30/40] document some unreachable errors --- .../tests/runtime_analysis_tests.rs | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index e5e4087271c..aa9e520df1e 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -243,16 +243,21 @@ fn check_error_kind_union_type_value_error_cdeploy() { // ValueOutOfBounds, // Unreachable: validated before reaching the runtime error // TypeSignatureTooDeep, [`check_error_kind_type_signature_too_deep_cdeploy`] // ExpectedName, // Unreachable: every place in the runtime where ExpectedName is raised comes from a direct call to SymbolicExpression::match_atom() on the original AST node and the type checker runs the same structure check during analysis. -// SupertypeTooLarge, +// SupertypeTooLarge, // unreachable: equality's least_supertype checks already run in analysis, and +// // runtime values are sanitized to their declared signatures, so the VM never +// // sees a pair of values whose unified type wasn't accepted earlier. // Expects(String), // unreachable -// BadMatchOptionSyntax(Box), -// BadMatchResponseSyntax(Box), -// BadMatchInput(Box), -// ListTypesMustMatch, +// BadMatchOptionSyntax(Box), Unreachable: Both the analyzer and the runtime examine the exact same match AST slice. The static pass invokes check_special_match_opt, which enforces the three-argument structure and the some binding name before any code is accepted. +// BadMatchResponseSyntax(Box), Unreachable: Both the analyzer and the runtime examine the exact same match AST slice. The static pass invokes check_special_match_resp, which enforces the four-argument structure and the ok and err binding names before any code is accepted. +// BadMatchInput(Box), Unreachable: Both the analyzer and the runtime examine the exact same match AST slice. The static pass invokes check_special_match, which enforces the two-argument structure and the input type before any code is accepted. +// ListTypesMustMatch, // Unrechable: list construction, append, replace-at?, and cons_list all sanitize their inputs before runtime // TypeError(Box, Box), // TypeValueError(Box, Box), [`check_error_kind_type_value_error_cdeploy`] -// InvalidTypeDescription, -// UnknownTypeName(String), +// InvalidTypeDescription, // unreachable: every invalid type literal is parsed both +// // by the analyzer and by the runtime; both paths invoke +// // the same TypeSignature::parse_* helpers, so analysis +// // always fails before initialization can trigger it. +// UnknownTypeName(String), // Unreachable: static analysis catches invalid types via `TypeSignature::parse_atom_type`, returning `StaticCheckErrorKind::UnknownTypeName`. // UnionTypeError(Vec, Box), // UnionTypeValueError(Vec, Box), // ExpectedOptionalValue(Box), From f4927dfac2c3830ada87dfbc1011c5074c5b70c3 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Fri, 21 Nov 2025 16:59:13 +0000 Subject: [PATCH 31/40] remove useless to_add --- .../tests/runtime_analysis_tests.rs | 28 +++----- ..._kind_contract_call_expect_name_ccall.snap | 68 +++++++++---------- ...ind_contract_call_expect_name_cdeploy.snap | 36 +++++----- 3 files changed, 63 insertions(+), 69 deletions(-) diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index aa9e520df1e..1bf8d07c8a2 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -190,16 +190,13 @@ fn check_error_kind_contract_call_expect_name_cdeploy() { contract_deploy_consensus_test!( contract_name: "contract-3", - contract_code: &format!( - " - (use-trait simple-trait .contract-1.simple-trait) + contract_code: " + (use-trait simple-trait .contract-1.simple-trait) - ;; Evaluated during initialization; runtime cannot resolve the callable. - (define-constant default-target '{}.contract-2) + ;; Evaluated during initialization; runtime cannot resolve the callable. + (define-constant default-target .contract-2) - (contract-call? default-target ping)", - to_addr(&FAUCET_PRIV_KEY), - ), + (contract-call? default-target ping)", setup_contracts: &[contract_1, contract_2], ); } @@ -379,17 +376,14 @@ fn check_error_kind_contract_call_expect_name_ccall() { contract_call_consensus_test!( contract_name: "contract-3", - contract_code: &format!( - " - (use-trait simple-trait .contract-1.simple-trait) + contract_code: " + (use-trait simple-trait .contract-1.simple-trait) - ;; Trait reference stored as a constant. - (define-constant default-target '{}.contract-2) + ;; Trait reference stored as a constant. + (define-constant default-target .contract-2) - (define-public (trigger-error) - (contract-call? default-target ping))", - to_addr(&FAUCET_PRIV_KEY), - ), + (define-public (trigger-error) + (contract-call? default-target ping))", function_name: "trigger-error", function_args: &[], deploy_epochs: EPOCHS_TO_TEST, diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_ccall.snap index 4c585152f20..beb2cb2b4f9 100644 --- a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_ccall.snap +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_ccall.snap @@ -60,7 +60,7 @@ expression: result ), )), Success(ExpectedBlockOutput( - marf_hash: "bb6dd7e3caa6503a5be1ae4ca5eeac6c4b699e83dc0f4b4329dce6072ba8a402", + marf_hash: "e492cab7e7fd788b41982e9e19a31874964ab13a3bd61b02d1ce5ec50de47bfc", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -77,7 +77,7 @@ expression: result write_count: 1, read_length: 5, read_count: 2, - runtime: 8509, + runtime: 8455, ), ), ], @@ -86,11 +86,11 @@ expression: result write_count: 1, read_length: 5, read_count: 2, - runtime: 8509, + runtime: 8455, ), )), Success(ExpectedBlockOutput( - marf_hash: "f572e132f368b52f6b8e94ff65d84d01d5eae91ba178e09ecc5bb93417d359c2", + marf_hash: "332edf4cf46b9042daabb3f9e061fa3d9d47dc08efd796146d41a02555a7f6c4", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -101,24 +101,24 @@ expression: result data: Bool(true), )), cost: ExecutionCost( - write_length: 295, + write_length: 293, write_count: 2, read_length: 9, read_count: 3, - runtime: 20724, + runtime: 20648, ), ), ], total_block_cost: ExecutionCost( - write_length: 295, + write_length: 293, write_count: 2, read_length: 9, read_count: 3, - runtime: 20724, + runtime: 20648, ), )), Success(ExpectedBlockOutput( - marf_hash: "6ad91317b50a0d03310acafda9b377cee9d2b817d3605e0e96a51a6aa4bf1497", + marf_hash: "648aa0bd75d6fcdd2b214f33f2bb477e45fb26100da045b0eed27248674e8950", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -129,24 +129,24 @@ expression: result data: Bool(true), )), cost: ExecutionCost( - write_length: 295, + write_length: 293, write_count: 2, read_length: 9, read_count: 3, - runtime: 20724, + runtime: 20648, ), ), ], total_block_cost: ExecutionCost( - write_length: 295, + write_length: 293, write_count: 2, read_length: 9, read_count: 3, - runtime: 20724, + runtime: 20648, ), )), Success(ExpectedBlockOutput( - marf_hash: "83e0f96934db11fe510a13e61c6852f446acd038b9559266e4eb3dac9d6d6ba4", + marf_hash: "ee312241064ac7ac37096ee1c01f17c74c569775257769b024e49758ff62d6ba", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -157,24 +157,24 @@ expression: result data: Bool(true), )), cost: ExecutionCost( - write_length: 295, + write_length: 293, write_count: 2, read_length: 9, read_count: 3, - runtime: 20724, + runtime: 20648, ), ), ], total_block_cost: ExecutionCost( - write_length: 295, + write_length: 293, write_count: 2, read_length: 9, read_count: 3, - runtime: 20724, + runtime: 20648, ), )), Success(ExpectedBlockOutput( - marf_hash: "99dd71c6488ddcd3e733430bf50b47d69247574fa946cd5e3ae0dec0ea4d7afe", + marf_hash: "acf96313b1b0cc9776af1af52b117b3e9b5a5575b75169253aa9b8b24efcae8a", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -204,7 +204,7 @@ expression: result ), )), Success(ExpectedBlockOutput( - marf_hash: "6cfdbaa75802d2c5d43c3f4a86934d4127bb67518ccb7c79c32a05f7a27ceaf8", + marf_hash: "599b26ffb52fb5b22a6e127b5d4afc98a6c663aac4f04fcc5d92e905ea3c8d15", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -219,22 +219,22 @@ expression: result cost: ExecutionCost( write_length: 0, write_count: 0, - read_length: 422, + read_length: 420, read_count: 3, - runtime: 656, + runtime: 654, ), ), ], total_block_cost: ExecutionCost( write_length: 0, write_count: 0, - read_length: 422, + read_length: 420, read_count: 3, - runtime: 656, + runtime: 654, ), )), Success(ExpectedBlockOutput( - marf_hash: "9caf6f2aef5f239a157116e2a575a8d9e200ad9c91ea486c8bac6e20d855ad5a", + marf_hash: "fd1c86eef556a32a899997a31db976de8c03af5e65f52ca2983661ba6df692e7", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -249,22 +249,22 @@ expression: result cost: ExecutionCost( write_length: 0, write_count: 0, - read_length: 422, + read_length: 420, read_count: 3, - runtime: 656, + runtime: 654, ), ), ], total_block_cost: ExecutionCost( write_length: 0, write_count: 0, - read_length: 422, + read_length: 420, read_count: 3, - runtime: 656, + runtime: 654, ), )), Success(ExpectedBlockOutput( - marf_hash: "96f015194f2bf6d725132ef1fbac105a781963673405717e41712a5e229fac18", + marf_hash: "22a8f5603701eecc5d645dd3554254fece09f1848fdc03a033b34f9cb78e6f2e", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -279,18 +279,18 @@ expression: result cost: ExecutionCost( write_length: 0, write_count: 0, - read_length: 422, + read_length: 420, read_count: 3, - runtime: 656, + runtime: 654, ), ), ], total_block_cost: ExecutionCost( write_length: 0, write_count: 0, - read_length: 422, + read_length: 420, read_count: 3, - runtime: 656, + runtime: 654, ), )), ] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_cdeploy.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_cdeploy.snap index 3eddae86c5d..e199a653507 100644 --- a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_cdeploy.snap +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_contract_call_expect_name_cdeploy.snap @@ -60,7 +60,7 @@ expression: result ), )), Success(ExpectedBlockOutput( - marf_hash: "fa8b39ecda5b526d30a1c6a6bfa6e07314190f4dab63828fc80ab5c394e8623a", + marf_hash: "1db39215fa26536780994c01b73e2307740af39a2d40dedf7d2d11c86dc59390", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -77,7 +77,7 @@ expression: result write_count: 1, read_length: 5, read_count: 2, - runtime: 8285, + runtime: 8015, ), ), ], @@ -86,11 +86,11 @@ expression: result write_count: 1, read_length: 5, read_count: 2, - runtime: 8285, + runtime: 8015, ), )), Success(ExpectedBlockOutput( - marf_hash: "e90c914a105efe16dd0e8597057b2ada9c1cd9f2518977e0b893f4ae6b229e3f", + marf_hash: "9b5db0038f9e50b8de04a19e2bc30aecd5e3e723e1aa63c31c0baa1afeac745d", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -103,24 +103,24 @@ expression: result )), )), cost: ExecutionCost( - write_length: 283, + write_length: 273, write_count: 2, read_length: 9, read_count: 3, - runtime: 20284, + runtime: 19904, ), ), ], total_block_cost: ExecutionCost( - write_length: 283, + write_length: 273, write_count: 2, read_length: 9, read_count: 3, - runtime: 20284, + runtime: 19904, ), )), Success(ExpectedBlockOutput( - marf_hash: "9d87e24037bc57ce7fcdf895df5bf5b16e4f038712a86f5b00c678b1c5e74d54", + marf_hash: "e2297fce49e8507d7f84e87762729cd1de820055e24f76c29421758d089d631d", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -133,24 +133,24 @@ expression: result )), )), cost: ExecutionCost( - write_length: 283, + write_length: 273, write_count: 2, read_length: 9, read_count: 3, - runtime: 20284, + runtime: 19904, ), ), ], total_block_cost: ExecutionCost( - write_length: 283, + write_length: 273, write_count: 2, read_length: 9, read_count: 3, - runtime: 20284, + runtime: 19904, ), )), Success(ExpectedBlockOutput( - marf_hash: "e636370df609897b28e1f05cd743600c92d7e4b4ed3a20eb4092bb0f83773368", + marf_hash: "27765660fa31b7736ce047df092d3702475c1fc23ac526e5d1554d27f98f8e80", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -163,20 +163,20 @@ expression: result )), )), cost: ExecutionCost( - write_length: 283, + write_length: 273, write_count: 2, read_length: 9, read_count: 3, - runtime: 20284, + runtime: 19904, ), ), ], total_block_cost: ExecutionCost( - write_length: 283, + write_length: 273, write_count: 2, read_length: 9, read_count: 3, - runtime: 20284, + runtime: 19904, ), )), ] From f1f987b6f9e5bb1fa1770c2866bf0e561bf7ff51 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Mon, 24 Nov 2025 11:23:03 +0000 Subject: [PATCH 32/40] fix check_error_kind_union_type_value_error_ccall --- .../tests/runtime_analysis_tests.rs | 16 ++++++++-- ...ror_kind_union_type_value_error_ccall.snap | 32 ++----------------- 2 files changed, 16 insertions(+), 32 deletions(-) diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index 64bf55eb348..e9198e406a5 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -17,6 +17,7 @@ use std::collections::HashMap; +use clarity::types::StacksEpochId; #[allow(unused_imports)] use clarity::vm::analysis::CheckErrorKind; use clarity::vm::types::{QualifiedContractIdentifier, MAX_TYPE_DEPTH}; @@ -256,8 +257,18 @@ fn check_error_kind_union_type_value_error_cdeploy() { // // the same TypeSignature::parse_* helpers, so analysis // // always fails before initialization can trigger it. // UnknownTypeName(String), // Unreachable: static analysis catches invalid types via `TypeSignature::parse_atom_type`, returning `StaticCheckErrorKind::UnknownTypeName`. -// UnionTypeError(Vec, Box), -// UnionTypeValueError(Vec, Box), +// UnionTypeError(Vec, Box), Unreachable: +// // the analyzer enforces that every call to `bit-shift-left` / `bit-shift-right` +// // supplies an argument whose type is exactly `int` or `uint` (see +// // `NativeFunctions::BitwiseLShift|BitwiseRShift` using +// // `FunctionArgSignature::Union(IntType, UIntType)` and the +// // `TypeSignature::admits_type` checks in `type_checker::check_function_arg_signature`). +// // All dynamic sources that might yield a different runtime value (trait dispatch, +// // consensus buffers, callable constants, etc.) either fail earlier with their own +// // `CheckErrorKind` (e.g. `ReturnTypesMustMatch`, `UnionTypeValueError`) or sanitize +// // the value before it can reach the bitwise native. As a result, the VM never receives +// // a non-integer argument at these call sites, so this variant cannot be exercised. +// UnionTypeValueError(Vec, Box), [`check_error_kind_union_type_value_error_cdeploy`] [`check_error_kind_union_type_value_error_ccall`] // ExpectedOptionalValue(Box), // ExpectedResponseValue(Box), // ExpectedOptionalOrResponseValue(Box), @@ -515,6 +526,7 @@ fn check_error_kind_union_type_value_error_ccall() { (foo .contract-1))", function_name: "trigger-runtime-error", function_args: &[], + deploy_epochs: &StacksEpochId::ALL[11..], // Epochs 3.3 and later exclude_clarity_versions: &[ClarityVersion::Clarity1, ClarityVersion::Clarity2, ClarityVersion::Clarity3], setup_contracts: &[contract_1], ); diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_ccall.snap index 7809c74be6b..dfa0384f3e3 100644 --- a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_ccall.snap +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_union_type_value_error_ccall.snap @@ -4,35 +4,7 @@ expression: result --- [ Success(ExpectedBlockOutput( - marf_hash: "b9c8422f985da80d714ac47d9b547a9dce5877b510749b82e9e5bc90a36dd8c7", - evaluated_epoch: Epoch20, - transactions: [ - ExpectedTransactionOutput( - tx: "SmartContract(name: contract-1, code_body: [..], clarity_version: None)", - vm_error: "None [NON-CONSENSUS BREAKING]", - return_type: Response(ResponseData( - committed: true, - data: Bool(true), - )), - cost: ExecutionCost( - write_length: 58, - write_count: 2, - read_length: 1, - read_count: 1, - runtime: 565000, - ), - ), - ], - total_block_cost: ExecutionCost( - write_length: 58, - write_count: 2, - read_length: 1, - read_count: 1, - runtime: 565000, - ), - )), - Success(ExpectedBlockOutput( - marf_hash: "05142693c23e7aaf7bddb457b19e36e2990b4d0412cbe76b448bc5753a20b821", + marf_hash: "7c0dcc19543ecca0386f4e3cc052e097cc11f8633787e51bde1e021915f965fa", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -60,7 +32,7 @@ expression: result ), )), Success(ExpectedBlockOutput( - marf_hash: "8232aa03717c4a276de9cdedac5031274e925d8f49e7be54d0e0f7fb72f62c25", + marf_hash: "72bc1062d04aba71e6dd6699d63e92a38894aee94ef51d79d5438b0722d7e5db", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( From 45d7dbd49f981e2ec4bad073f64e9cb1c7ef1d96 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Tue, 25 Nov 2025 15:48:06 +0000 Subject: [PATCH 33/40] add tests for ExpectedContractPrincipalValue and CouldNotDetermineType --- stackslib/src/chainstate/tests/consensus.rs | 2 +- .../tests/runtime_analysis_tests.rs | 161 ++++++++++++- ...r_kind_could_not_determine_type_ccall.snap | 214 ++++++++++++++++++ ...pected_contract_principal_value_ccall.snap | 64 ++++++ ...cted_contract_principal_value_cdeploy.snap | 36 +++ ...or_kind_list_types_must_match_cdeploy.snap | 124 ++++++++++ 6 files changed, 599 insertions(+), 2 deletions(-) create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_could_not_determine_type_ccall.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_expected_contract_principal_value_ccall.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_expected_contract_principal_value_cdeploy.snap create mode 100644 stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_list_types_must_match_cdeploy.snap diff --git a/stackslib/src/chainstate/tests/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index 12604542098..d4e3680da0c 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -1062,7 +1062,7 @@ impl ContractConsensusTest<'_> { assert!( setup_contracts .iter() - .all(|c| c.deploy_epoch.is_none() || c.deploy_epoch.unwrap() >= *min_deploy_epoch), + .all(|c| c.deploy_epoch.is_none() || c.deploy_epoch.unwrap() <= *min_deploy_epoch), "All setup contracts must have a deploy epoch >= the minimum deploy epoch" ); diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index e9198e406a5..55df6e6081c 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -232,6 +232,88 @@ fn check_error_kind_union_type_value_error_cdeploy() { ); } +/// CheckErrorKind: [`CheckErrorKind::ListTypesMustMatch`] +/// Caused by: +/// Outcome: block accepted. +/// Note: The error is only triggered since Clarity 2. In Clarity 1 the tx is valid and accepted. +#[test] +fn check_error_kind_list_types_must_match_cdeploy() { + let contract_1 = SetupContract::new( + "contract-1", + " +(define-trait trait-a ( + (ping () (response bool uint)))) + +(define-trait trait-b ( + (pong () (response bool uint))))", + ); + let contract_2 = SetupContract::new( + "contract-2", + " +;; Implements both trait interfaces defined in contract-3 and exposes a +;; helper that returns a list mixing the two callable types. + +(use-trait trait-a .contract-1.trait-a) +(use-trait trait-b .contract-1.trait-b) + +(impl-trait .contract-1.trait-a) +(impl-trait .contract-1.trait-b) + +(define-public (ping) + (ok true)) + +(define-public (pong) + (ok true)) + +(define-public (make-callables (first ) (second )) + ;; Returning mixedgenous callable references forces the runtime to + ;; sanitize a `ListUnionType` value. + (ok (list first second)))", + ); + + contract_deploy_consensus_test!( + contract_name: "contract-3", + contract_code: " +;; Contract under test: during initialization it defines a constant list that +;; mixes callable references to two distinct traits. The list's entry type is a +;; `ListUnionType`, which the runtime sanitization in `put_value_with_size` +;; cannot admit, triggering `CheckErrorKind::CouldNotDetermineType`. + +(use-trait trait-a .contract-1.trait-a) +(use-trait trait-b .contract-1.trait-b) + +(define-private (as-trait-a (target )) target) +(define-private (as-trait-b (target )) target) + +(define-constant mixed-callables + (list + (as-trait-a .contract-2) + (as-trait-b .contract-2))) + +(define-public (noop) + (ok u0)) +", + setup_contracts: &[contract_1, contract_2], + ); +} + +/// CheckErrorKind: [`CheckErrorKind::ExpectedContractPrincipalValue`] +/// Caused by: Supplying tx-sender to with-ft inside as-contract? forces eval_allowance to inspect a standard principal +/// Outcome: block accepted. +/// Note: This test only works for Clarity 4 and later. 'as-contract?' is not supported in earlier versions. +#[test] +fn check_error_kind_expected_contract_principal_value_cdeploy() { + contract_deploy_consensus_test!( + contract_name: "contract", + contract_code: r#" + (define-constant trigger-error + (as-contract? + ((with-ft tx-sender "token" u0)) + true))"#, + exclude_clarity_versions: &[ClarityVersion::Clarity1, ClarityVersion::Clarity2, ClarityVersion::Clarity3], + ); +} + // pub enum CheckErrorKind { // CostOverflow, // Unreachable: should exceed u64 // CostBalanceExceeded(ExecutionCost, ExecutionCost), [`check_error_cost_balance_exceeded_cdeploy`] @@ -273,7 +355,7 @@ fn check_error_kind_union_type_value_error_cdeploy() { // ExpectedResponseValue(Box), // ExpectedOptionalOrResponseValue(Box), // ExpectedContractPrincipalValue(Box), -// CouldNotDetermineType, +// CouldNotDetermineType, [`check_error_kind_could_not_determine_type_cdeploy`] [`check_error_kind_could_not_determine_type_ccall`] // BadTokenName, // NoSuchNFT(String), // NoSuchFT(String), @@ -531,3 +613,80 @@ fn check_error_kind_union_type_value_error_ccall() { setup_contracts: &[contract_1], ); } + +/// CheckErrorKind: [`CheckErrorKind::ExpectedContractPrincipalValue`] +/// Caused by: Supplying tx-sender to with-ft inside as-contract? forces eval_allowance to inspect a standard principal +/// Outcome: block accepted. +/// Note: This test only works for Clarity 4 and later. 'as-contract?' is not supported in earlier versions. +#[test] +fn check_error_kind_expected_contract_principal_value_ccall() { + contract_call_consensus_test!( + contract_name: "contract", + contract_code: r#" + (define-public (trigger-error) + (as-contract? + ((with-ft tx-sender "token" u0)) + true))"#, + function_name: "trigger-error", + function_args: &[], + deploy_epochs: &StacksEpochId::ALL[11..], // Epochs 3.3 and later + exclude_clarity_versions: &[ClarityVersion::Clarity1, ClarityVersion::Clarity2, ClarityVersion::Clarity3], + ); +} + +/// CheckErrorKind: [`CheckErrorKind::CouldNotDetermineType`] +/// Caused by: reading a constant that was created in a pre-2.4 epoch without +/// value sanitization. The constant stores a mixed list of callable +/// references which cannot be sanitized once sanitization is enforced. +/// Outcome: block accepted. +/// Note: This test only works in Clarity 2 deployed in Epoch 2.3. +#[test] +fn check_error_kind_could_not_determine_type_ccall() { + let trait_contract = SetupContract::new( + "contract-traits", + " + (define-trait trait-a ( + (ping () (response bool uint)))) + (define-trait trait-b ( + (pong () (response bool uint))))", + ) + .with_epoch(StacksEpochId::Epoch23); + + let trait_impl = SetupContract::new( + "trait-impl", + " + (use-trait trait-a .contract-traits.trait-a) + (use-trait trait-b .contract-traits.trait-b) + + (impl-trait .contract-traits.trait-a) + (impl-trait .contract-traits.trait-b) + + (define-public (ping) (ok true)) + (define-public (pong) (ok true))", + ) + .with_epoch(StacksEpochId::Epoch23); + + contract_call_consensus_test!( + contract_name: "mixed-constant", + contract_code: " + (use-trait trait-a .contract-traits.trait-a) + (use-trait trait-b .contract-traits.trait-b) + + (define-private (cast-a (target )) target) + (define-private (cast-b (target )) target) + + (define-constant mixed + (list + (cast-a .trait-impl) + (cast-b .trait-impl))) + + (define-public (trigger-error) + (ok mixed))", + function_name: "trigger-error", + function_args: &[], + deploy_epochs: &[StacksEpochId::Epoch23], + call_epochs: &StacksEpochId::ALL[6..], // Epochs 2.4 and later + exclude_clarity_versions: &[ClarityVersion::Clarity1, ClarityVersion::Clarity3, ClarityVersion::Clarity4], + setup_contracts: &[trait_contract, trait_impl], + ); +} diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_could_not_determine_type_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_could_not_determine_type_ccall.snap new file mode 100644 index 00000000000..a432f9ba75a --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_could_not_determine_type_ccall.snap @@ -0,0 +1,214 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "847643b0f429f82e39efe0557b9028e28e39fb96a44e47a413d025aa3fd49693", + evaluated_epoch: Epoch23, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: mixed-constant-Epoch2_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 469, + write_count: 2, + read_length: 15, + read_count: 5, + runtime: 40411, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 469, + write_count: 2, + read_length: 15, + read_count: 5, + runtime: 40411, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1e1c2a70d338329d148e1b417a2cfc785d1e0c26403cae5b97a8b49a34ba1af9", + evaluated_epoch: Epoch24, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: mixed-constant-Epoch2_3-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(CouldNotDetermineType) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "571c0c7f27296ce1732975416706e9502f9c04ec2ca0fd3c9009fcab7f09288f", + evaluated_epoch: Epoch25, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: mixed-constant-Epoch2_3-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(CouldNotDetermineType) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "22b69b427d8707933848097bff4c3c4108a8c28e7b8a42f792bfc2e4bbb4468b", + evaluated_epoch: Epoch30, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: mixed-constant-Epoch2_3-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(CouldNotDetermineType) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e3985286d1b6361bebb65227b3c751394afd010718e802ab838ee9d471d10061", + evaluated_epoch: Epoch31, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: mixed-constant-Epoch2_3-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(CouldNotDetermineType) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "28561492691efc4d14197ee64e9480d2b386a427b472a8dcafa5547c4fe18661", + evaluated_epoch: Epoch32, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: mixed-constant-Epoch2_3-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(CouldNotDetermineType) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "e325646aeb312545532ec162e66287dcb0c6027c9c3dc51e2aaa7e65b7cb3a08", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: mixed-constant-Epoch2_3-Clarity2, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(CouldNotDetermineType) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 720, + read_count: 3, + runtime: 1426, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_expected_contract_principal_value_ccall.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_expected_contract_principal_value_ccall.snap new file mode 100644 index 00000000000..b9197e41055 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_expected_contract_principal_value_ccall.snap @@ -0,0 +1,64 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "042c2d4c0277139c8de76ad68d6bdae22a0ad3032dcddf774f983cf19d56c0bb", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 168, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 14420, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 168, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 14420, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "bccef81ca460f9c06b67be7cd7623a024bc5147483662a4dee97e706956c2065", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "ContractCall(address: ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP, contract_name: contract-Epoch3_3-Clarity4, function_name: trigger-error, function_args: [[]])", + vm_error: "Some(ExpectedContractPrincipalValue(Principal(Standard(StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP))))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 154, + read_count: 3, + runtime: 1267, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 154, + read_count: 3, + runtime: 1267, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_expected_contract_principal_value_cdeploy.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_expected_contract_principal_value_cdeploy.snap new file mode 100644 index 00000000000..d47f8b5720e --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_expected_contract_principal_value_cdeploy.snap @@ -0,0 +1,36 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "4bb61c6c901f6b64e204f2f46fe76c46341e0f51c7f13c647969315276d5a385", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(ExpectedContractPrincipalValue(Principal(Standard(StandardPrincipalData(ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP))))) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 167, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 15231, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 167, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 15231, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_list_types_must_match_cdeploy.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_list_types_must_match_cdeploy.snap new file mode 100644 index 00000000000..c7ed4c973c3 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_list_types_must_match_cdeploy.snap @@ -0,0 +1,124 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "2d2d0d956cfde874c6498ec93e4b6eb0f2c8d302adac86d1d2c80564d5274687", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + vm_error: "None [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: true, + data: Bool(true), + )), + cost: ExecutionCost( + write_length: 700, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 40532, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 700, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 40532, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4fe5bc0175c9fcba8266016426a771550dde116fa1cd09f315c8ab00c00e712d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + vm_error: "Some(ListTypesMustMatch) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 700, + write_count: 2, + read_length: 17, + read_count: 5, + runtime: 48076, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 700, + write_count: 2, + read_length: 17, + read_count: 5, + runtime: 48076, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "7538e1e394b7a2477bff94ef286282b24dbfba8c1a724726db4ba7050eaa1a6d", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + vm_error: "Some(ListTypesMustMatch) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 700, + write_count: 2, + read_length: 17, + read_count: 5, + runtime: 48076, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 700, + write_count: 2, + read_length: 17, + read_count: 5, + runtime: 48076, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "ad3c2e3fa2b47f143b588120e21930b7f02cd412113a2dd826e8d41f48735fe2", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: contract-3-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + vm_error: "Some(ListTypesMustMatch) [NON-CONSENSUS BREAKING]", + return_type: Response(ResponseData( + committed: false, + data: Optional(OptionalData( + data: None, + )), + )), + cost: ExecutionCost( + write_length: 700, + write_count: 2, + read_length: 17, + read_count: 5, + runtime: 48076, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 700, + write_count: 2, + read_length: 17, + read_count: 5, + runtime: 48076, + ), + )), +] From 244f0f4762a6cadbfeab85a0ea52b7581009a48d Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Tue, 25 Nov 2025 16:25:29 +0000 Subject: [PATCH 34/40] document other unreachable errors --- .../tests/runtime_analysis_tests.rs | 24 +++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index 55df6e6081c..82e4acdb4e0 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -351,10 +351,26 @@ fn check_error_kind_expected_contract_principal_value_cdeploy() { // // the value before it can reach the bitwise native. As a result, the VM never receives // // a non-integer argument at these call sites, so this variant cannot be exercised. // UnionTypeValueError(Vec, Box), [`check_error_kind_union_type_value_error_cdeploy`] [`check_error_kind_union_type_value_error_ccall`] -// ExpectedOptionalValue(Box), -// ExpectedResponseValue(Box), -// ExpectedOptionalOrResponseValue(Box), -// ExpectedContractPrincipalValue(Box), +// ExpectedOptionalValue(Box), // Unreachable: every optional primitive (`is-some`, +// // `default-to`, `unwrap!`, etc.) has a dedicated +// // analysis hook (`check_special_is_optional`, +// // `check_special_default_to`, `inner_unwrap`, …) that +// // enforces the optional type before a contract can be +// // published, so the runtime never sees a plain `Value` +// // arrive at `native_default_to` / `is_some`. +// ExpectedResponseValue(Box), // Unreachable for the same reason: response helpers are +// // validated by `check_special_is_response` / +// // `inner_unwrap_err` during static analysis, preventing a +// // non-response from reaching the runtime handlers. +// ExpectedOptionalOrResponseValue(Box), // Unreachable: the mixed helpers (`match`, +// // `try!`, `unwrap!`/`unwrap-err!`) ultimately +// // delegate to `check_special_match` / +// // `inner_unwrap` in the analyzer, which enforce +// // that the argument is either an optional or a +// // response before the code is accepted. There is +// // no runtime path where a plain value reaches +// // `native_try_ret` or the option/response matchers. +// ExpectedContractPrincipalValue(Box), [`check_error_kind_expected_contract_principal_value_cdeploy`] [`check_error_kind_expected_contract_principal_value_ccall`] // CouldNotDetermineType, [`check_error_kind_could_not_determine_type_cdeploy`] [`check_error_kind_could_not_determine_type_ccall`] // BadTokenName, // NoSuchNFT(String), From 0f3b086e4f009a313cfa86a36070213cd9bb7046 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Thu, 27 Nov 2025 15:08:29 +0000 Subject: [PATCH 35/40] add new unreachable variants --- .../tests/runtime_analysis_tests.rs | 33 ++++++++++++++----- 1 file changed, 25 insertions(+), 8 deletions(-) diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index 82e4acdb4e0..788caef7bd8 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -372,14 +372,31 @@ fn check_error_kind_expected_contract_principal_value_cdeploy() { // // `native_try_ret` or the option/response matchers. // ExpectedContractPrincipalValue(Box), [`check_error_kind_expected_contract_principal_value_cdeploy`] [`check_error_kind_expected_contract_principal_value_ccall`] // CouldNotDetermineType, [`check_error_kind_could_not_determine_type_cdeploy`] [`check_error_kind_could_not_determine_type_ccall`] -// BadTokenName, -// NoSuchNFT(String), -// NoSuchFT(String), -// BadTransferSTXArguments, -// BadTransferFTArguments, -// BadTransferNFTArguments, -// BadMintFTArguments, -// BadBurnFTArguments, +// BadTokenName, // Unreachable: asset natives call `match_atom()` on their token arg during analysis, +// NoSuchNFT(String), // Unreachable: analysis uses contract_context.get_nft_type during every nft-* checker, +// // so a reference to an undefined NFT aborts before initialization. +// NoSuchFT(String), // Unreachable: ft-* analyzers call contract_context.ft_exists, preventing undefined +// // fungible tokens from ever reaching the runtime handlers. +// BadTransferSTXArguments, // Unreachable: the analyzer routes all `stx-transfer?`, +// // `stx-transfer-memo?`, and `stx-burn?` calls through +// // `check_special_stx_transfer[_memo]` / `check_special_stx_burn` +// // (`clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs`), +// // which demand a `(uint, principal, principal)` (plus memo) signature +// // before a contract can be published. Because the runtime caches only +// // sanitized values, `special_stx_transfer` never receives a malformed +// // tuple of arguments and this variant cannot fire. +// BadTransferFTArguments, // Unreachable: `check_special_transfer_token` enforces the +// // `(uint, principal, principal)` argument contract for every FT +// // transfer during analysis, so `special_transfer_token` never sees a +// // mismatched set of values at runtime. +// BadTransferNFTArguments, // Unreachable: `check_special_transfer_asset` ensures that the NFT +// // identifier plus `(principal, principal)` pair have the right types, +// // preventing `special_transfer_asset` from failing later. +// BadMintFTArguments, // Unreachable: `check_special_mint_token` requires a `(uint, principal)` +// // argument tuple for fungible minting before deployment, so the runtime +// // never raises `BadMintFTArguments`. +// BadBurnFTArguments, // Unreachable: `check_special_burn_token` enforces `(uint, principal)` +// // during static analysis, making the runtime variant unobservable. // ExpectedTuple(Box), // NoSuchTupleField(String, TupleTypeSignature), // EmptyTuplesNotAllowed, From ca3c05c4756999d3e9613a62c869a668d4a3bdb5 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Thu, 27 Nov 2025 18:04:44 +0000 Subject: [PATCH 36/40] more unreachable errors --- .../tests/runtime_analysis_tests.rs | 25 +++++++++++++++---- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index 788caef7bd8..6c0c5a0ab6c 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -397,11 +397,26 @@ fn check_error_kind_expected_contract_principal_value_cdeploy() { // // never raises `BadMintFTArguments`. // BadBurnFTArguments, // Unreachable: `check_special_burn_token` enforces `(uint, principal)` // // during static analysis, making the runtime variant unobservable. -// ExpectedTuple(Box), -// NoSuchTupleField(String, TupleTypeSignature), -// EmptyTuplesNotAllowed, -// NoSuchDataVariable(String), -// NoSuchMap(String), +// ExpectedTuple(Box), // Unreachable: `check_special_get`/`check_special_merge` ensure every +// // `(get …)`/`(merge …)` argument is statically typed as a tuple (or +// // option wrapping a tuple), so `tuple_get` / `tuple_merge` never see +// // a non-tuple at runtime. +// NoSuchTupleField(String, TupleTypeSignature), // Unreachable: `check_special_get` verifies tuple field existence +// // for every `(get …)` (including option-wrapped cases) before +// // deploy, so `tuple_get` never receives a missing field. +// EmptyTuplesNotAllowed, // Unreachable: all code paths producing this error call `parse_type_repr` +// // (via `TupleTypeSignature::try_from`), which runs during BOTH static +// // analysis and runtime. Since static analysis runs first during contract +// // deployment, `StaticCheckErrorKind::EmptyTuplesNotAllowed` is always +// // triggered before the runtime equivalent. The only other path +// // (`TupleData::from_data`) is protected by `check_arguments_at_least(1, args)` +// // in `tuple_cons`, preventing empty tuple construction at runtime. +// NoSuchDataVariable(String), // Unreachable: the analyzer registers every `(define-data-var …)` +// // in `contract_context.meta_data_var` before any other top-level +// // expression runs, so every `var-get`/`var-set` lookup already +// // has a descriptor or fails during static analysis. +// NoSuchMap(String), // Unreachable: analysis uses contract_context.get_map_type during every +// // map-* checker, so a reference to an undefined map aborts before initialization. // DefineFunctionBadSignature, // BadFunctionName, // PublicFunctionMustReturnResponse(Box), From 26e2e081bfbab94c25bde569e148d93a31b73a9a Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Mon, 1 Dec 2025 15:20:49 +0000 Subject: [PATCH 37/40] update tests --- .../tests/runtime_analysis_tests.rs | 14 +++---- ...or_kind_list_types_must_match_cdeploy.snap | 40 +++++++++---------- 2 files changed, 27 insertions(+), 27 deletions(-) diff --git a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs index 6c0c5a0ab6c..f7f302bd6bf 100644 --- a/stackslib/src/chainstate/tests/runtime_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -417,14 +417,14 @@ fn check_error_kind_expected_contract_principal_value_cdeploy() { // // has a descriptor or fails during static analysis. // NoSuchMap(String), // Unreachable: analysis uses contract_context.get_map_type during every // // map-* checker, so a reference to an undefined map aborts before initialization. -// DefineFunctionBadSignature, -// BadFunctionName, -// PublicFunctionMustReturnResponse(Box), +// DefineFunctionBadSignature, // Functionally Unreachable. On contract deploy checked during static analysis. +// BadFunctionName, // Functionally Unreachable. On contract deploy checked during static analysis. +// PublicFunctionMustReturnResponse(Box), // Functionally Unreachable. On contract deploy checked during static analysis. // ReturnTypesMustMatch(Box, Box), [`check_error_kind_return_types_must_match_ccall`] -// CircularReference(Vec), +// CircularReference(Vec), // Tested. Possible only during contract call. On contract deploy checked during parsing. // NoSuchContract(String), [`check_error_kind_no_such_contract_ccall`] -// NoSuchPublicFunction(String, String), -// PublicFunctionNotReadOnly(String, String), +// NoSuchPublicFunction(String, String), // Tested. Possible only during contract call. On contract deploy checked during static analysis +// PublicFunctionNotReadOnly(String, String), // Functionally Unreachable. Environment::inner_execute_contract is invoked with read_only = false on the relevant code path, causing PublicFunctionNotReadOnly check to be skipped. // ContractAlreadyExists(String), // ContractCallExpectName, [`check_error_kind_contract_call_expect_name_cdeploy`] // NoSuchBurnBlockInfoProperty(String), @@ -438,7 +438,7 @@ fn check_error_kind_expected_contract_principal_value_cdeploy() { // ExpectedSequence(Box), // BadLetSyntax, // BadSyntaxBinding(SyntaxBindingError), -// UndefinedFunction(String), // Unreachable? Wasn't able to trigger this error during contract initialization. +// UndefinedFunction(String), [`check_error_kind_undefined_function_ccall`] // UndefinedVariable(String), // RequiresAtLeastArguments(usize, usize), // RequiresAtMostArguments(usize, usize), diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_list_types_must_match_cdeploy.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_list_types_must_match_cdeploy.snap index c7ed4c973c3..872540fb317 100644 --- a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_list_types_must_match_cdeploy.snap +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_list_types_must_match_cdeploy.snap @@ -4,7 +4,7 @@ expression: result --- [ Success(ExpectedBlockOutput( - marf_hash: "2d2d0d956cfde874c6498ec93e4b6eb0f2c8d302adac86d1d2c80564d5274687", + marf_hash: "58cb97a3c14a8bd74d442590cb79a5f39561a7ffebe564c2678a603ec5e962d3", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -15,24 +15,24 @@ expression: result data: Bool(true), )), cost: ExecutionCost( - write_length: 700, + write_length: 699, write_count: 2, read_length: 9, read_count: 3, - runtime: 40532, + runtime: 40494, ), ), ], total_block_cost: ExecutionCost( - write_length: 700, + write_length: 699, write_count: 2, read_length: 9, read_count: 3, - runtime: 40532, + runtime: 40494, ), )), Success(ExpectedBlockOutput( - marf_hash: "4fe5bc0175c9fcba8266016426a771550dde116fa1cd09f315c8ab00c00e712d", + marf_hash: "2f43b561d9a329d9d78ef9ec91c76af8e7fd01985dd38c99d5d23f53a21afeb5", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -45,24 +45,24 @@ expression: result )), )), cost: ExecutionCost( - write_length: 700, + write_length: 699, write_count: 2, read_length: 17, read_count: 5, - runtime: 48076, + runtime: 48038, ), ), ], total_block_cost: ExecutionCost( - write_length: 700, + write_length: 699, write_count: 2, read_length: 17, read_count: 5, - runtime: 48076, + runtime: 48038, ), )), Success(ExpectedBlockOutput( - marf_hash: "7538e1e394b7a2477bff94ef286282b24dbfba8c1a724726db4ba7050eaa1a6d", + marf_hash: "e93942eff61da94e111d9b1453ef56acc2abf7ae4c9653cc52c2285386d76b96", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -75,24 +75,24 @@ expression: result )), )), cost: ExecutionCost( - write_length: 700, + write_length: 699, write_count: 2, read_length: 17, read_count: 5, - runtime: 48076, + runtime: 48038, ), ), ], total_block_cost: ExecutionCost( - write_length: 700, + write_length: 699, write_count: 2, read_length: 17, read_count: 5, - runtime: 48076, + runtime: 48038, ), )), Success(ExpectedBlockOutput( - marf_hash: "ad3c2e3fa2b47f143b588120e21930b7f02cd412113a2dd826e8d41f48735fe2", + marf_hash: "e8ed709257c04e7c4adfd2699b7ec2b9662b7160f7cb6c5a2fad941a486b2ac9", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -105,20 +105,20 @@ expression: result )), )), cost: ExecutionCost( - write_length: 700, + write_length: 699, write_count: 2, read_length: 17, read_count: 5, - runtime: 48076, + runtime: 48038, ), ), ], total_block_cost: ExecutionCost( - write_length: 700, + write_length: 699, write_count: 2, read_length: 17, read_count: 5, - runtime: 48076, + runtime: 48038, ), )), ] From 6eb5496822e730df878457dcfae9738f704efaab Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Tue, 2 Dec 2025 12:38:25 +0000 Subject: [PATCH 38/40] remove CheckErrorKind variants for static analysis only --- clarity-types/src/errors/analysis.rs | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index 732b159c52b..40f397302e2 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -831,8 +831,6 @@ pub enum CheckErrorKind { /// Attempt to write to contract state in a read-only function. WriteAttemptedInReadOnly, - /// `at-block` closure must be read-only but contains write operations. - AtBlockClosureMustBeReadOnly, // contract post-conditions /// Post-condition expects a list of asset allowances but received invalid input. @@ -843,15 +841,6 @@ pub enum CheckErrorKind { /// Expected an allowance expression but found invalid input. /// The `String` wraps the unexpected input. ExpectedAllowanceExpr(String), - /// `with-all-assets-unsafe` is not allowed in this context. - WithAllAllowanceNotAllowed, - /// `with-all-assets-unsafe` cannot be used alongside other allowances. - WithAllAllowanceNotAlone, - /// `with-nft` allowance requires a list of asset identifiers. - WithNftExpectedListOfIdentifiers, - /// `with-nft` allowance identifiers list exceeds the maximum allowed length. - /// The first `u32` represents the maximum length, and the second represents the actual length. - MaxIdentifierLengthExceeded(u32, u32), /// Too many allowances specified in post-condition. /// The first `usize` represents the maximum allowed, and the second represents the actual count. TooManyAllowances(usize, usize), @@ -1470,7 +1459,6 @@ impl DiagnosableError for CheckErrorKind { CheckErrorKind::TooManyFunctionParameters(found, allowed) => format!("too many function parameters specified: found {found}, the maximum is {allowed}"), CheckErrorKind::TraitBasedContractCallInReadOnly => "use of trait based contract calls are not allowed in read-only context".into(), CheckErrorKind::WriteAttemptedInReadOnly => "expecting read-only statements, detected a writing operation".into(), - CheckErrorKind::AtBlockClosureMustBeReadOnly => "(at-block ...) closures expect read-only statements, but detected a writing operation".into(), CheckErrorKind::BadTokenName => "expecting an token name as an argument".into(), CheckErrorKind::NoSuchNFT(asset_name) => format!("tried to use asset function with a undefined asset ('{asset_name}')"), CheckErrorKind::NoSuchFT(asset_name) => format!("tried to use token function with a undefined token ('{asset_name}')"), @@ -1488,10 +1476,6 @@ impl DiagnosableError for CheckErrorKind { CheckErrorKind::ExpectedListOfAllowances(fn_name, arg_num) => format!("{fn_name} expects a list of asset allowances as argument {arg_num}"), CheckErrorKind::AllowanceExprNotAllowed => "allowance expressions are only allowed in the context of a `restrict-assets?` or `as-contract?`".into(), CheckErrorKind::ExpectedAllowanceExpr(got_name) => format!("expected an allowance expression, got: {got_name}"), - CheckErrorKind::WithAllAllowanceNotAllowed => "with-all-assets-unsafe is not allowed here, only in the allowance list for `as-contract?`".into(), - CheckErrorKind::WithAllAllowanceNotAlone => "with-all-assets-unsafe must not be used along with other allowances".into(), - CheckErrorKind::WithNftExpectedListOfIdentifiers => "with-nft allowance must include a list of asset identifiers".into(), - CheckErrorKind::MaxIdentifierLengthExceeded(max_len, len) => format!("with-nft allowance identifiers list must not exceed {max_len} elements, got {len}"), CheckErrorKind::TooManyAllowances(max_allowed, found) => format!("too many allowances specified, the maximum is {max_allowed}, found {found}"), } } From a6ee03cb59735ceaebf9127966d89c5eb541ed9d Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Tue, 2 Dec 2025 13:21:00 +0000 Subject: [PATCH 39/40] add docstring for impl From for String --- clarity-types/src/errors/analysis.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index 40f397302e2..e9d19fa65f7 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -1198,6 +1198,8 @@ impl From for StaticCheckErrorKind { } } +/// This conversion is provided to support tests in +/// `clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs`. #[cfg(any(test, feature = "testing"))] impl From for String { fn from(o: StaticCheckErrorKind) -> Self { From ebd47f53f3593f28ed06bb50c2c07e1ab524f0b4 Mon Sep 17 00:00:00 2001 From: Francesco Leacche Date: Tue, 2 Dec 2025 13:21:32 +0000 Subject: [PATCH 40/40] remove impl DiagnosableError for CheckErrorKind --- clarity-types/src/errors/analysis.rs | 108 --------------------------- 1 file changed, 108 deletions(-) diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index e9d19fa65f7..14f34b0ba73 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -1387,111 +1387,3 @@ impl DiagnosableError for StaticCheckErrorKind { } } } - -impl DiagnosableError for CheckErrorKind { - fn message(&self) -> String { - match &self { - CheckErrorKind::SupertypeTooLarge => "supertype of two types is too large".into(), - CheckErrorKind::Expects(s) => format!("unexpected interpreter behavior: {s}"), - CheckErrorKind::BadMatchOptionSyntax(source) => - format!("match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: {}", - source.message()), - CheckErrorKind::BadMatchResponseSyntax(source) => - format!("match on a result type uses the following syntax: (match input ok-name if-ok-expression err-name if-err-expression). Caused by: {}", - source.message()), - CheckErrorKind::BadMatchInput(t) => - format!("match requires an input of either a response or optional, found input: '{t}'"), - CheckErrorKind::CostOverflow => "contract execution cost overflowed cost counter".into(), - CheckErrorKind::CostBalanceExceeded(a, b) => format!("contract execution cost exceeded budget: {a:?} > {b:?}"), - CheckErrorKind::MemoryBalanceExceeded(a, b) => format!("contract execution cost exceeded memory budget: {a:?} > {b:?}"), - CheckErrorKind::CostComputationFailed(s) => format!("contract cost computation failed: {s}"), - CheckErrorKind::ExecutionTimeExpired => "execution time expired".into(), - CheckErrorKind::InvalidTypeDescription => "supplied type description is invalid".into(), - CheckErrorKind::EmptyTuplesNotAllowed => "tuple types may not be empty".into(), - CheckErrorKind::UnknownTypeName(name) => format!("failed to parse type: '{name}'"), - CheckErrorKind::ValueTooLarge => "created a type which was greater than maximum allowed value size".into(), - CheckErrorKind::ValueOutOfBounds => "created a type which value size was out of defined bounds".into(), - CheckErrorKind::TypeSignatureTooDeep => "created a type which was deeper than maximum allowed type depth".into(), - CheckErrorKind::ExpectedName => "expected a name argument to this function".into(), - CheckErrorKind::ListTypesMustMatch => "expecting elements of same type in a list".into(), - CheckErrorKind::TypeError(expected_type, found_type) => format!("expecting expression of type '{expected_type}', found '{found_type}'"), - CheckErrorKind::TypeValueError(expected_type, found_value) => format!("expecting expression of type '{expected_type}', found '{found_value}'"), - CheckErrorKind::UnionTypeError(expected_types, found_type) => format!("expecting expression of type {}, found '{}'", formatted_expected_types(expected_types), found_type), - CheckErrorKind::UnionTypeValueError(expected_types, found_type) => format!("expecting expression of type {}, found '{}'", formatted_expected_types(expected_types), found_type), - CheckErrorKind::ExpectedOptionalOrResponseValue(found_value) => format!("expecting expression of type 'optional' or 'response', found '{found_value}'"), - CheckErrorKind::ExpectedOptionalValue(found_value) => format!("expecting expression of type 'optional', found '{found_value}'"), - CheckErrorKind::ExpectedResponseValue(found_value) => format!("expecting expression of type 'response', found '{found_value}'"), - CheckErrorKind::ExpectedContractPrincipalValue(found_value) => format!("expecting contract principal value, found '{found_value}'"), - CheckErrorKind::CouldNotDetermineType => "type of expression cannot be determined".into(), - CheckErrorKind::ExpectedTuple(type_signature) => format!("expecting tuple, found '{type_signature}'"), - CheckErrorKind::NoSuchTupleField(field_name, tuple_signature) => format!("cannot find field '{field_name}' in tuple '{tuple_signature}'"), - CheckErrorKind::NoSuchDataVariable(var_name) => format!("use of unresolved persisted variable '{var_name}'"), - CheckErrorKind::BadTransferSTXArguments => "STX transfer expects an int amount, from principal, to principal".into(), - CheckErrorKind::BadTransferFTArguments => "transfer expects an int amount, from principal, to principal".into(), - CheckErrorKind::BadTransferNFTArguments => "transfer expects an asset, from principal, to principal".into(), - CheckErrorKind::BadMintFTArguments => "mint expects a uint amount and from principal".into(), - CheckErrorKind::BadBurnFTArguments => "burn expects a uint amount and from principal".into(), - CheckErrorKind::NoSuchMap(map_name) => format!("use of unresolved map '{map_name}'"), - CheckErrorKind::DefineFunctionBadSignature => "invalid function definition".into(), - CheckErrorKind::BadFunctionName => "invalid function name".into(), - CheckErrorKind::PublicFunctionMustReturnResponse(found_type) => format!("public functions must return an expression of type 'response', found '{found_type}'"), - CheckErrorKind::ReturnTypesMustMatch(type_1, type_2) => format!("detected two execution paths, returning two different expression types (got '{type_1}' and '{type_2}')"), - CheckErrorKind::NoSuchContract(contract_identifier) => format!("use of unresolved contract '{contract_identifier}'"), - CheckErrorKind::NoSuchPublicFunction(contract_identifier, function_name) => format!("contract '{contract_identifier}' has no public function '{function_name}'"), - CheckErrorKind::PublicFunctionNotReadOnly(contract_identifier, function_name) => format!("function '{contract_identifier}' in '{function_name}' is not read-only"), - CheckErrorKind::ContractAlreadyExists(contract_identifier) => format!("contract name '{contract_identifier}' conflicts with existing contract"), - CheckErrorKind::ContractCallExpectName => "missing contract name for call".into(), - CheckErrorKind::NoSuchBurnBlockInfoProperty(property_name) => format!("use of burn block unknown property '{property_name}'"), - CheckErrorKind::NoSuchStacksBlockInfoProperty(property_name) => format!("use of unknown stacks block property '{property_name}'"), - CheckErrorKind::GetBlockInfoExpectPropertyName => "missing property name for block info introspection".into(), - CheckErrorKind::GetStacksBlockInfoExpectPropertyName => "missing property name for stacks block info introspection".into(), - CheckErrorKind::GetTenureInfoExpectPropertyName => "missing property name for tenure info introspection".into(), - CheckErrorKind::NameAlreadyUsed(name) => format!("defining '{name}' conflicts with previous value"), - CheckErrorKind::NonFunctionApplication => "expecting expression of type function".into(), - CheckErrorKind::ExpectedListApplication => "expecting expression of type list".into(), - CheckErrorKind::ExpectedSequence(found_type) => format!("expecting expression of type 'list', 'buff', 'string-ascii' or 'string-utf8' - found '{found_type}'"), - CheckErrorKind::BadLetSyntax => "invalid syntax of 'let'".into(), - CheckErrorKind::CircularReference(references) => format!("detected circular reference: ({})", references.join(", ")), - CheckErrorKind::BadSyntaxBinding(binding_error) => format!("invalid syntax binding: {}", &binding_error.message()), - CheckErrorKind::UndefinedVariable(var_name) => format!("use of unresolved variable '{var_name}'"), - CheckErrorKind::UndefinedFunction(var_name) => format!("use of unresolved function '{var_name}'"), - CheckErrorKind::RequiresAtLeastArguments(expected, found) => format!("expecting >= {expected} arguments, got {found}"), - CheckErrorKind::RequiresAtMostArguments(expected, found) => format!("expecting < {expected} arguments, got {found}"), - CheckErrorKind::IncorrectArgumentCount(expected_count, found_count) => format!("expecting {expected_count} arguments, got {found_count}"), - CheckErrorKind::TooManyFunctionParameters(found, allowed) => format!("too many function parameters specified: found {found}, the maximum is {allowed}"), - CheckErrorKind::TraitBasedContractCallInReadOnly => "use of trait based contract calls are not allowed in read-only context".into(), - CheckErrorKind::WriteAttemptedInReadOnly => "expecting read-only statements, detected a writing operation".into(), - CheckErrorKind::BadTokenName => "expecting an token name as an argument".into(), - CheckErrorKind::NoSuchNFT(asset_name) => format!("tried to use asset function with a undefined asset ('{asset_name}')"), - CheckErrorKind::NoSuchFT(asset_name) => format!("tried to use token function with a undefined token ('{asset_name}')"), - CheckErrorKind::TraitReferenceUnknown(trait_name) => format!("use of undeclared trait <{trait_name}>"), - CheckErrorKind::TraitMethodUnknown(trait_name, func_name) => format!("method '{func_name}' unspecified in trait <{trait_name}>"), - CheckErrorKind::BadTraitImplementation(trait_name, func_name) => format!("invalid signature for method '{func_name}' regarding trait's specification <{trait_name}>"), - CheckErrorKind::ExpectedTraitIdentifier => "expecting expression of type trait identifier".into(), - CheckErrorKind::DefineTraitBadSignature => "invalid trait definition".into(), - CheckErrorKind::DefineTraitDuplicateMethod(method_name) => format!("duplicate method name '{method_name}' in trait definition"), - CheckErrorKind::ContractOfExpectsTrait => "trait reference expected".into(), - CheckErrorKind::TraitTooManyMethods(found, allowed) => format!("too many trait methods specified: found {found}, the maximum is {allowed}"), - CheckErrorKind::InvalidCharactersDetected => "invalid characters detected".into(), - CheckErrorKind::InvalidUTF8Encoding => "invalid UTF8 encoding".into(), - CheckErrorKind::InvalidSecp65k1Signature => "invalid seckp256k1 signature".into(), - CheckErrorKind::ExpectedListOfAllowances(fn_name, arg_num) => format!("{fn_name} expects a list of asset allowances as argument {arg_num}"), - CheckErrorKind::AllowanceExprNotAllowed => "allowance expressions are only allowed in the context of a `restrict-assets?` or `as-contract?`".into(), - CheckErrorKind::ExpectedAllowanceExpr(got_name) => format!("expected an allowance expression, got: {got_name}"), - CheckErrorKind::TooManyAllowances(max_allowed, found) => format!("too many allowances specified, the maximum is {max_allowed}, found {found}"), - } - } - - fn suggestion(&self) -> Option { - match &self { - CheckErrorKind::BadLetSyntax => Some( - "'let' syntax example: (let ((supply 1000) (ttl 60)) )".into(), - ), - CheckErrorKind::TraitReferenceUnknown(_) => Some( - "traits should be either defined, with define-trait, or imported, with use-trait." - .into(), - ), - _ => None, - } - } -}