diff --git a/clarity-types/src/errors/analysis.rs b/clarity-types/src/errors/analysis.rs index f98348f6077..7fc5d65f635 100644 --- a/clarity-types/src/errors/analysis.rs +++ b/clarity-types/src/errors/analysis.rs @@ -136,16 +136,458 @@ 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) + } +} + +/// 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. +/// +/// 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. +#[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 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), + /// Too many function parameters specified. + /// The first `usize` represents the number of parameters found, the second represents the maximum allowed. + TooManyFunctionParameters(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, + /// Trait definition contains duplicate method names. + /// The `String` wraps the duplicate method name. + DefineTraitDuplicateMethod(String), + /// Too many trait methods specified. + /// The first `usize` represents the number of methods found, the second the maximum allowed. + TraitTooManyMethods(usize, usize), +} + +/// 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. + /// 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. + 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 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 + /// 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. + /// Unreachable: should exceed u32 elements in memory. + 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 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. + 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), + /// Too many function parameters specified. + /// The first `usize` represents the number of parameters found, the second represents the maximum allowed. + TooManyFunctionParameters(usize, usize), + + // 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. + 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), + /// Too many trait methods specified. + /// The first `usize` represents the number of methods found, the second the maximum allowed. + TraitTooManyMethods(usize, usize), + + /// 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. + /// The first `String` wraps the function name, and the second `i32` wraps the argument number. + ExpectedListOfAllowances(String, i32), + /// Allowance expressions are only allowed in specific contexts (`restrict-assets?` or `as-contract?`). + AllowanceExprNotAllowed, + /// 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), +} + +/// 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 +637,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 +660,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 +669,17 @@ 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,19 +700,14 @@ 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), /// 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, - /// 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 +715,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 +724,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 +750,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 +768,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 +777,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 +787,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,29 +804,11 @@ 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), /// Too many function parameters specified. /// The first `usize` represents the number of parameters found, the second represents the maximum allowed. TooManyFunctionParameters(usize, usize), // 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), @@ -450,9 +816,8 @@ 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, - /// 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), @@ -461,15 +826,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), /// Too many trait methods specified. /// The first `usize` represents the number of methods found, the second the maximum allowed. TraitTooManyMethods(usize, usize), @@ -513,12 +874,15 @@ pub enum CheckErrorKind { } #[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. @@ -526,8 +890,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, @@ -536,8 +899,18 @@ impl CheckErrorKind { } } +impl StaticCheckErrorKind { + /// This check indicates that the transaction should be rejected. + 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), @@ -560,30 +933,40 @@ 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 } } +impl From<(CommonCheckErrorKind, &SymbolicExpression)> for StaticCheckError { + fn from(e: (CommonCheckErrorKind, &SymbolicExpression)) -> Self { + Self::with_expression(e.0.into(), e.1) + } +} + 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<(CommonCheckErrorKind, &SymbolicExpression)> for CommonCheckErrorKind { + fn from(e: (CommonCheckErrorKind, &SymbolicExpression)) -> Self { + e.0 } } -impl From<(CheckErrorKind, &SymbolicExpression)> for StaticCheckError { - fn from(e: (CheckErrorKind, &SymbolicExpression)) -> Self { - let mut ce = Self::new(e.0); - ce.set_expression(e.1); - ce +impl From<(CommonCheckErrorKind, &SymbolicExpression)> for CheckErrorKind { + fn from(e: (CommonCheckErrorKind, &SymbolicExpression)) -> Self { + e.0.into() } } -impl From<(CheckErrorKind, &SymbolicExpression)> for CheckErrorKind { - fn from(e: (CheckErrorKind, &SymbolicExpression)) -> Self { - e.0 +impl fmt::Display for CommonCheckErrorKind { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{self:?}") } } @@ -593,6 +976,12 @@ impl fmt::Display for CheckErrorKind { } } +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)?; @@ -607,7 +996,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, + } } } @@ -630,6 +1042,35 @@ 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 CommonCheckErrorKind { + fn source(&self) -> Option<&(dyn error::Error + 'static)> { + None + } +} + impl error::Error for StaticCheckError { fn source(&self) -> Option<&(dyn error::Error + 'static)> { None @@ -642,30 +1083,172 @@ 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::TooManyFunctionParameters(found, allowed) => { + CheckErrorKind::TooManyFunctionParameters(found, allowed) + } + 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::TraitTooManyMethods(found, allowed) => { + CheckErrorKind::TraitTooManyMethods(found, allowed) + } + 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::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::TooManyFunctionParameters(found, allowed) => { + StaticCheckErrorKind::TooManyFunctionParameters(found, allowed) + } + 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::TraitTooManyMethods(found, allowed) => { + StaticCheckErrorKind::TraitTooManyMethods(found, allowed) + } + 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::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(), )) @@ -674,9 +1257,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(), )) @@ -700,6 +1283,136 @@ fn formatted_expected_types(expected_types: &[TypeSignature]) -> String { expected_types_joined } +impl DiagnosableError for StaticCheckErrorKind { + fn message(&self) -> String { + match &self { + 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()), + 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()), + StaticCheckErrorKind::BadMatchInput(t) => + format!("match requires an input of either a response or optional, found input: '{t}'"), + 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::CostComputationFailed(s) => format!("contract cost computation failed: {s}"), + StaticCheckErrorKind::ExecutionTimeExpired => "execution time expired".into(), + 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::TooManyFunctionParameters(found, allowed) => format!("too many function parameters specified: found {found}, the maximum is {allowed}"), + StaticCheckErrorKind::WriteAttemptedInReadOnly => "expecting read-only statements, detected a writing operation".into(), + StaticCheckErrorKind::AtBlockClosureMustBeReadOnly => "(at-block ...) closures expect read-only statements, but detected a writing operation".into(), + StaticCheckErrorKind::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::TraitTooManyMethods(found, allowed) => format!("too many trait methods specified: found {found}, the maximum is {allowed}"), + 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::CouldNotDetermineSerializationType => "could not determine the input type for the serialization function".into(), + StaticCheckErrorKind::ExpectedListOfAllowances(fn_name, arg_num) => format!("{fn_name} expects a list of asset allowances as argument {arg_num}"), + StaticCheckErrorKind::AllowanceExprNotAllowed => "allowance expressions are only allowed in the context of a `restrict-assets?` or `as-contract?`".into(), + StaticCheckErrorKind::ExpectedAllowanceExpr(got_name) => format!("expected an allowance expression, got: {got_name}"), + StaticCheckErrorKind::WithAllAllowanceNotAllowed => "with-all-assets-unsafe is not allowed here, only in the allowance list for `as-contract?`".into(), + StaticCheckErrorKind::WithAllAllowanceNotAlone => "with-all-assets-unsafe must not be used along with other allowances".into(), + StaticCheckErrorKind::WithNftExpectedListOfIdentifiers => "with-nft allowance must include a list of asset identifiers".into(), + StaticCheckErrorKind::MaxIdentifierLengthExceeded(max_len, len) => format!("with-nft allowance identifiers list must not exceed {max_len} elements, got {len}"), + StaticCheckErrorKind::TooManyAllowances(max_allowed, found) => format!("too many allowances specified, the maximum is {max_allowed}, found {found}"), + + } + } + + 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 { @@ -716,6 +1429,8 @@ impl DiagnosableError for CheckErrorKind { 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}'"), @@ -724,104 +1439,68 @@ impl DiagnosableError for CheckErrorKind { 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::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::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::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::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::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::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::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::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::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::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::ExecutionTimeExpired => "execution time expired".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}"), @@ -842,9 +1521,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 34f03a549cb..4db200c3121 100644 --- a/clarity-types/src/errors/mod.rs +++ b/clarity-types/src/errors/mod.rs @@ -20,7 +20,7 @@ pub mod lexer; use std::{error, fmt}; -pub use analysis::{CheckErrorKind, StaticCheckError}; +pub use analysis::{CheckErrorKind, CommonCheckErrorKind, StaticCheckError, StaticCheckErrorKind}; pub use ast::{ParseError, ParseErrorKind, ParseResult}; pub use cost::CostErrors; pub use lexer::LexerError; @@ -292,15 +292,21 @@ impl From for 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) } } -impl From<(CheckErrorKind, &SymbolicExpression)> for VmExecutionError { - fn from(err: (CheckErrorKind, &SymbolicExpression)) -> Self { - VmExecutionError::Unchecked(err.0) +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 d6581a3523f..a8d6af2f256 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, RuntimeError, VmExecutionError, VmInternalError}; use crate::representations::{ClarityName, ContractName, SymbolicExpression}; @@ -711,7 +712,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; @@ -736,7 +737,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(), ))) @@ -756,9 +757,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, @@ -779,9 +782,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), @@ -805,9 +810,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), @@ -823,19 +830,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)?, @@ -847,7 +854,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..9747aca13de 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::StaticCheckErrorKind; use crate::errors::{CheckErrorKind, IncomparableError, VmInternalError}; use crate::representations::{ClarityName, ContractName, MAX_STRING_LEN}; use crate::types::{ @@ -394,7 +395,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 +406,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 +418,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 +435,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 +446,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 +469,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 +478,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 +486,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 +506,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) } } @@ -612,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( @@ -844,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 { @@ -869,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 dd68701210a..13ce2becc0a 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); } @@ -934,18 +935,18 @@ impl TypeSignature { /// Creates a string ASCII type with the specified length. /// Returns an error if the provided length is invalid. - pub fn new_ascii_type(len: i128) -> Result { + pub fn new_ascii_type(len: i128) -> Result { Ok(SequenceType(SequenceSubtype::StringType( StringSubtype::ASCII(BufferLength::try_from_i128(len)?), ))) } /// 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, - ) -> Result { + ) -> Result { if a.is_no_type() { Ok(b.clone()) } else if b.is_no_type() { @@ -996,7 +997,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 @@ -1008,16 +1009,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( + fn least_supertype_v2_0( a: &TypeSignature, b: &TypeSignature, - ) -> Result { + ) -> Result { match (a, b) { ( TupleType(TupleTypeSignature { type_map: types_a }), @@ -1025,7 +1026,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()), ))?; @@ -1034,7 +1035,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 { @@ -1055,7 +1056,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 = @@ -1114,7 +1115,7 @@ impl TypeSignature { if x == y { Ok(x.clone()) } else { - Err(CheckErrorKind::TypeError( + Err(CommonCheckErrorKind::TypeError( Box::new(a.clone()), Box::new(b.clone()), )) @@ -1123,10 +1124,10 @@ impl TypeSignature { } } - pub fn least_supertype_v2_1( + pub(crate) fn least_supertype_v2_1( a: &TypeSignature, b: &TypeSignature, - ) -> Result { + ) -> Result { match (a, b) { ( TupleType(TupleTypeSignature { type_map: types_a }), @@ -1134,7 +1135,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()), ))?; @@ -1143,7 +1144,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 { @@ -1164,7 +1165,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 = @@ -1245,7 +1246,7 @@ impl TypeSignature { if all_principals { Ok(PrincipalType) } else { - Err(CheckErrorKind::TypeError( + Err(CommonCheckErrorKind::TypeError( Box::new(a.clone()), Box::new(b.clone()), )) @@ -1258,7 +1259,7 @@ impl TypeSignature { if x == y { Ok(x.clone()) } else { - Err(CheckErrorKind::TypeError( + Err(CommonCheckErrorKind::TypeError( Box::new(a.clone()), Box::new(b.clone()), )) @@ -1270,7 +1271,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()) } @@ -1281,7 +1282,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, @@ -1310,29 +1311,31 @@ 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, CheckErrorKind> = - args.iter().map(TypeSignature::type_of).collect(); - TypeSignature::parent_list_type(&children_types?) + let children_types: Result, _> = args.iter().map(TypeSignature::type_of).collect(); + 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()) @@ -1372,16 +1375,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). @@ -1414,9 +1417,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_ @@ -1446,7 +1449,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()? @@ -1512,7 +1515,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/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(), + )), } } 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..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, SyntaxBindingError, SyntaxBindingErrorType, + CommonCheckErrorKind, StaticCheckError, StaticCheckErrorKind, SyntaxBindingError, + SyntaxBindingErrorType, }; diff --git a/clarity/src/vm/analysis/mod.rs b/clarity/src/vm/analysis/mod.rs index 2ae4e1c79a8..fac0cce6e73 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}; +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; @@ -55,7 +57,7 @@ pub fn mem_type_check( ) -> Result<(Option, ContractAnalysis), StaticCheckError> { let contract_identifier = QualifiedContractIdentifier::transient(); let contract = build_ast(&contract_identifier, snippet, &mut (), version, epoch) - .map_err(|e| CheckErrorKind::Expects(format!("Failed to build AST: {e}")))? + .map_err(|e| StaticCheckErrorKind::Expects(format!("Failed to build AST: {e}")))? .expressions; let mut marf = MemoryBackingStore::new(); @@ -73,16 +75,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 +152,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 0c62c80e4dd..dd486172527 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); } @@ -396,7 +396,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) } @@ -413,7 +413,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(|| { @@ -488,7 +490,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( @@ -509,7 +511,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { } _ => { return Err(StaticCheckError::new( - CheckErrorKind::ContractCallExpectName, + StaticCheckErrorKind::ContractCallExpectName, )) } }; @@ -527,7 +529,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { let allowances = args[1] .match_list() - .ok_or(CheckErrorKind::ExpectedListOfAllowances( + .ok_or(StaticCheckErrorKind::ExpectedListOfAllowances( "restrict-assets?".into(), 2, ))?; @@ -545,7 +547,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { let allowances = args[0] .match_list() - .ok_or(CheckErrorKind::ExpectedListOfAllowances( + .ok_or(StaticCheckErrorKind::ExpectedListOfAllowances( "as-contract?".into(), 1, ))?; @@ -575,11 +577,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 { @@ -587,10 +589,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..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,7 +15,7 @@ // 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 +28,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 +58,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 +81,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 +114,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 +127,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 +143,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 +177,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 +191,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 +207,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 +227,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 +260,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 +273,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 3cbe844478e..1cc33db4554 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)), @@ -825,7 +840,7 @@ impl TypedNativeFunction { | AllowanceWithStacking | AllowanceAll | Secp256r1Verify => { - 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 66d7e4a6c8c..fbbbc8fb572 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; @@ -168,14 +168,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( @@ -199,7 +191,7 @@ impl FunctionType { if !admitted { return ( cost, - Err(CheckErrorKind::TypeError( + Err(StaticCheckErrorKind::TypeError( Box::new(expected_type.clone()), Box::new(arg_type.clone()), ) @@ -218,7 +210,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()), ) @@ -227,10 +219,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()), ) @@ -253,10 +245,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)) @@ -269,7 +262,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)) @@ -280,7 +273,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)) @@ -300,7 +293,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()), ) @@ -318,7 +311,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()), ) @@ -336,10 +329,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)?; @@ -364,14 +358,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()), )), @@ -379,7 +376,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()), ) @@ -413,7 +410,7 @@ impl FunctionType { }; if !first_type_supported { - return Err(CheckErrorKind::UnionTypeError( + return Err(StaticCheckErrorKind::UnionTypeError( vec![ TypeSignature::IntType, TypeSignature::UIntType, @@ -455,7 +452,7 @@ impl FunctionType { }; if !pair_of_types_matches { - return Err(CheckErrorKind::TypeError( + return Err(StaticCheckErrorKind::TypeError( Box::new(first.clone()), Box::new(second.clone()), ) @@ -500,7 +497,7 @@ impl FunctionType { depth: u8, ) -> Result { if depth > MAX_TYPE_DEPTH { - return Err(CheckErrorKind::TypeSignatureTooDeep.into()); + return Err(StaticCheckErrorKind::TypeSignatureTooDeep.into()); } Ok(match value { @@ -570,7 +567,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)?; @@ -584,7 +583,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( @@ -592,8 +591,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( @@ -605,7 +606,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()), ) @@ -644,7 +645,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()), ) @@ -661,7 +662,7 @@ fn check_function_arg_signature( } } if !admitted { - return Err(CheckErrorKind::UnionTypeError( + return Err(StaticCheckErrorKind::UnionTypeError( expected_types.clone(), Box::new(actual_type.clone()), ) @@ -742,14 +743,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()), ) @@ -770,7 +771,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 @@ -823,7 +824,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()), ) @@ -835,7 +836,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()), ) @@ -855,7 +856,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()), ) @@ -888,24 +889,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( @@ -933,7 +934,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()), ) @@ -955,7 +956,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(), ))? @@ -982,7 +983,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(), ) @@ -1020,14 +1021,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, @@ -1096,7 +1097,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { &return_type, ) .map_err(|_| { - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( Box::new(expected_type), Box::new(return_type), ) @@ -1127,7 +1128,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)?; @@ -1204,15 +1205,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) @@ -1275,9 +1277,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 @@ -1307,10 +1313,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))?; if self.epoch.limits_parameter_and_method_count() && args.len() > MAX_FUNCTION_PARAMETERS { - return Err(CheckErrorKind::TooManyFunctionParameters( + return Err(StaticCheckErrorKind::TooManyFunctionParameters( args.len(), MAX_FUNCTION_PARAMETERS, ) @@ -1319,7 +1325,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { 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, @@ -1328,7 +1334,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()); @@ -1384,7 +1390,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { &return_type, ) .map_err(|_| { - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( Box::new(expected.clone()), Box::new(return_type), ) @@ -1424,10 +1430,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))) } @@ -1459,19 +1465,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) @@ -1503,7 +1511,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( @@ -1515,7 +1523,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()) } } } @@ -1534,7 +1542,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(), ))?; @@ -1544,13 +1552,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(), ))?; @@ -1567,7 +1575,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()), ) @@ -1591,7 +1599,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()); } }; @@ -1629,7 +1637,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()); } }; @@ -1661,7 +1669,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)?; @@ -1689,7 +1697,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)) } @@ -1764,9 +1772,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()); } } @@ -1907,9 +1915,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..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,7 +17,7 @@ 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 +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, @@ -58,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)?; @@ -79,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( @@ -110,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; @@ -121,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(( @@ -137,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( @@ -169,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; @@ -181,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(( @@ -225,7 +237,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 +260,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 +280,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 +313,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 +326,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/conversions.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs index 874084f16f6..3ad5fc72b59 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs @@ -1,4 +1,4 @@ -use clarity_types::errors::CheckErrorKind; +use clarity_types::errors::analysis::StaticCheckErrorKind; use clarity_types::types::{StringSubtype, MAX_TO_ASCII_BUFFER_LEN}; use stacks_common::types::StacksEpochId; @@ -62,7 +62,7 @@ pub fn check_special_to_ascii( check_argument_count(1, args)?; let input_type = checker.type_check( args.first() - .ok_or(CheckErrorKind::CheckerImplementationFailure)?, + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?, context, )?; @@ -92,12 +92,14 @@ pub fn check_special_to_ascii( TypeSignature::TO_ASCII_BUFFER_MAX, TypeSignature::STRING_UTF8_MAX, ]; - return Err(CheckErrorKind::UnionTypeError(types, input_type.into()).into()); + return Err(StaticCheckErrorKind::UnionTypeError(types, input_type.into()).into()); } }; Ok( TypeSignature::new_response(result_type, TypeSignature::UIntType).map_err(|_| { - CheckErrorKind::Expects("FATAL: Legal Clarity response type marked invalid".into()) + StaticCheckErrorKind::Expects( + "FATAL: Legal Clarity response type marked invalid".into(), + ) })?, ) } 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..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,7 +17,7 @@ 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 +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::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 +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::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 +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::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 267be5c9cb3..2496897dac3 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; @@ -70,14 +70,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 { @@ -97,7 +100,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) @@ -156,10 +159,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) } @@ -173,7 +178,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)?; @@ -185,10 +190,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()) } } @@ -202,13 +207,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, @@ -256,7 +261,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" ))); } @@ -266,8 +271,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)) } @@ -282,7 +288,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()?; @@ -295,9 +301,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)?; @@ -337,14 +343,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, @@ -362,14 +368,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, @@ -379,7 +389,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), ))) @@ -408,7 +418,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)) + }), ); } } @@ -419,7 +431,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) @@ -442,9 +456,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() }) } @@ -456,7 +472,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())?; @@ -481,10 +497,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(), + ), + )) } }?; @@ -504,7 +522,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()); @@ -514,15 +532,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, @@ -556,10 +573,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(), + ), + )) } }?; @@ -575,7 +594,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()); @@ -585,7 +604,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()); @@ -595,10 +614,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(), ), @@ -617,7 +636,7 @@ fn check_contract_call( } _ => { return Err(StaticCheckError::new( - CheckErrorKind::ContractCallExpectName, + StaticCheckErrorKind::ContractCallExpectName, )) } }; @@ -641,14 +660,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)?; @@ -656,7 +679,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) } @@ -670,7 +693,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()))?, ) } @@ -702,13 +725,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()))? ) } @@ -722,7 +745,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()))?, ) } @@ -758,13 +781,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)?; @@ -773,8 +796,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], @@ -783,19 +806,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()) })?, )?) } @@ -808,11 +831,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(), )), )?; @@ -830,12 +853,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)?; @@ -865,7 +888,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 { @@ -894,7 +917,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(), ) })?, @@ -905,7 +928,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(), ) })?, @@ -916,7 +939,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(), ) })?, @@ -927,11 +950,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(), ) })?, @@ -943,11 +967,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(), ) })?, @@ -983,7 +1008,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(), ) })?, @@ -1036,7 +1061,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(), ) })?, @@ -1048,7 +1073,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(), ) })?, @@ -1056,7 +1081,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), @@ -1065,11 +1091,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(), ) @@ -1085,7 +1113,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(), ) })?, @@ -1096,7 +1124,7 @@ impl TypedNativeFunction { ("unlock-height".into(), TypeSignature::UIntType), ]) .map_err(|_| { - CheckErrorKind::Expects( + StaticCheckErrorKind::Expects( "FAIL: StxGetAccount failed to initialize type signature".into(), ) })? @@ -1107,7 +1135,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(), ) })?, @@ -1115,7 +1143,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(), ) })?, @@ -1125,7 +1153,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( @@ -1208,7 +1236,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(), ) })?, @@ -1217,7 +1245,7 @@ impl TypedNativeFunction { TypeSignature::BUFFER_32, TypeSignature::UIntType, ) - .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?, + .map_err(|_| StaticCheckErrorKind::Expects("Bad constructor".into()))?, }))), ToAscii => Special(SpecialNativeFunction(&conversions::check_special_to_ascii)), RestrictAssets => Special(SpecialNativeFunction( 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/post_conditions.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/post_conditions.rs index dc862545adb..4288820fd62 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/post_conditions.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/post_conditions.rs @@ -13,8 +13,10 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use clarity_types::errors::analysis::{check_argument_count, check_arguments_at_least}; -use clarity_types::errors::{CheckErrorKind, StaticCheckError}; +use clarity_types::errors::analysis::{ + check_argument_count, check_arguments_at_least, StaticCheckErrorKind, +}; +use clarity_types::errors::StaticCheckError; use clarity_types::representations::SymbolicExpression; use clarity_types::types::{SequenceSubtype, TypeSignature}; @@ -40,21 +42,23 @@ pub fn check_restrict_assets( let asset_owner = args .first() - .ok_or(CheckErrorKind::CheckerImplementationFailure)?; + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?; let allowance_list = args .get(1) - .ok_or(CheckErrorKind::CheckerImplementationFailure)? + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)? .match_list() - .ok_or(CheckErrorKind::ExpectedListOfAllowances( + .ok_or(StaticCheckErrorKind::ExpectedListOfAllowances( "restrict-assets?".into(), 2, ))?; let body_exprs = args .get(2..) - .ok_or(CheckErrorKind::CheckerImplementationFailure)?; + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?; if allowance_list.len() > MAX_ALLOWANCES { - return Err(CheckErrorKind::TooManyAllowances(MAX_ALLOWANCES, allowance_list.len()).into()); + return Err( + StaticCheckErrorKind::TooManyAllowances(MAX_ALLOWANCES, allowance_list.len()).into(), + ); } runtime_cost( @@ -67,7 +71,7 @@ pub fn check_restrict_assets( for allowance in allowance_list { if check_allowance(checker, allowance, context)? { - return Err(CheckErrorKind::WithAllAllowanceNotAllowed.into()); + return Err(StaticCheckErrorKind::WithAllAllowanceNotAllowed.into()); } } @@ -76,12 +80,12 @@ pub fn check_restrict_assets( for expr in body_exprs { let type_return = checker.type_check(expr, context)?; if type_return.is_response_type() { - return Err(CheckErrorKind::UncheckedIntermediaryResponses.into()); + return Err(StaticCheckErrorKind::UncheckedIntermediaryResponses.into()); } last_return = Some(type_return); } - let ok_type = last_return.ok_or_else(|| CheckErrorKind::CheckerImplementationFailure)?; + let ok_type = last_return.ok_or_else(|| StaticCheckErrorKind::CheckerImplementationFailure)?; Ok(TypeSignature::new_response( ok_type, TypeSignature::UIntType, @@ -97,18 +101,20 @@ pub fn check_as_contract( let allowance_list = args .first() - .ok_or(CheckErrorKind::CheckerImplementationFailure)? + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)? .match_list() - .ok_or(CheckErrorKind::ExpectedListOfAllowances( + .ok_or(StaticCheckErrorKind::ExpectedListOfAllowances( "as-contract?".into(), 1, ))?; let body_exprs = args .get(1..) - .ok_or(CheckErrorKind::CheckerImplementationFailure)?; + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?; if allowance_list.len() > MAX_ALLOWANCES { - return Err(CheckErrorKind::TooManyAllowances(MAX_ALLOWANCES, allowance_list.len()).into()); + return Err( + StaticCheckErrorKind::TooManyAllowances(MAX_ALLOWANCES, allowance_list.len()).into(), + ); } runtime_cost( @@ -119,7 +125,7 @@ pub fn check_as_contract( for allowance in allowance_list { if check_allowance(checker, allowance, context)? && allowance_list.len() > 1 { - return Err(CheckErrorKind::WithAllAllowanceNotAlone.into()); + return Err(StaticCheckErrorKind::WithAllAllowanceNotAlone.into()); } } @@ -128,12 +134,12 @@ pub fn check_as_contract( for expr in body_exprs { let type_return = checker.type_check(expr, context)?; if type_return.is_response_type() { - return Err(CheckErrorKind::UncheckedIntermediaryResponses.into()); + return Err(StaticCheckErrorKind::UncheckedIntermediaryResponses.into()); } last_return = Some(type_return); } - let ok_type = last_return.ok_or_else(|| CheckErrorKind::CheckerImplementationFailure)?; + let ok_type = last_return.ok_or_else(|| StaticCheckErrorKind::CheckerImplementationFailure)?; Ok(TypeSignature::new_response( ok_type, TypeSignature::UIntType, @@ -148,7 +154,7 @@ pub fn check_allowance_err( _args: &[SymbolicExpression], _context: &TypingContext, ) -> Result { - Err(CheckErrorKind::AllowanceExprNotAllowed.into()) + Err(StaticCheckErrorKind::AllowanceExprNotAllowed.into()) } /// Type check an allowance expression, returning whether it is a @@ -160,17 +166,17 @@ pub fn check_allowance( ) -> Result { let list = allowance .match_list() - .ok_or(CheckErrorKind::ExpectedListApplication)?; + .ok_or(StaticCheckErrorKind::ExpectedListApplication)?; let (allowance_fn, args) = list .split_first() - .ok_or(CheckErrorKind::ExpectedListApplication)?; + .ok_or(StaticCheckErrorKind::ExpectedListApplication)?; let function_name = allowance_fn .match_atom() - .ok_or(CheckErrorKind::NonFunctionApplication)?; + .ok_or(StaticCheckErrorKind::NonFunctionApplication)?; let Some(ref native_function) = NativeFunctions::lookup_by_name_at_version(function_name, &checker.clarity_version) else { - return Err(CheckErrorKind::ExpectedAllowanceExpr(function_name.to_string()).into()); + return Err(StaticCheckErrorKind::ExpectedAllowanceExpr(function_name.to_string()).into()); }; match native_function { @@ -181,7 +187,7 @@ pub fn check_allowance( check_allowance_with_stacking(checker, args, context) } NativeFunctions::AllowanceAll => check_allowance_all(checker, args, context), - _ => Err(CheckErrorKind::ExpectedAllowanceExpr(function_name.to_string()).into()), + _ => Err(StaticCheckErrorKind::ExpectedAllowanceExpr(function_name.to_string()).into()), } } @@ -196,7 +202,7 @@ fn check_allowance_with_stx( checker.type_check_expects( args.first() - .ok_or(CheckErrorKind::CheckerImplementationFailure)?, + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?, context, &TypeSignature::UIntType, )?; @@ -215,19 +221,19 @@ fn check_allowance_with_ft( checker.type_check_expects( args.first() - .ok_or(CheckErrorKind::CheckerImplementationFailure)?, + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?, context, &TypeSignature::PrincipalType, )?; checker.type_check_expects( args.get(1) - .ok_or(CheckErrorKind::CheckerImplementationFailure)?, + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?, context, &TypeSignature::STRING_ASCII_128, )?; checker.type_check_expects( args.get(2) - .ok_or(CheckErrorKind::CheckerImplementationFailure)?, + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?, context, &TypeSignature::UIntType, )?; @@ -246,13 +252,13 @@ fn check_allowance_with_nft( checker.type_check_expects( args.first() - .ok_or(CheckErrorKind::CheckerImplementationFailure)?, + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?, context, &TypeSignature::PrincipalType, )?; checker.type_check_expects( args.get(1) - .ok_or(CheckErrorKind::CheckerImplementationFailure)?, + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?, context, &TypeSignature::STRING_ASCII_128, )?; @@ -260,14 +266,14 @@ fn check_allowance_with_nft( // Asset identifiers must be a Clarity list with any type of elements let id_list_ty = checker.type_check( args.get(2) - .ok_or(CheckErrorKind::CheckerImplementationFailure)?, + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?, context, )?; let TypeSignature::SequenceType(SequenceSubtype::ListType(list_data)) = id_list_ty else { - return Err(CheckErrorKind::WithNftExpectedListOfIdentifiers.into()); + return Err(StaticCheckErrorKind::WithNftExpectedListOfIdentifiers.into()); }; if list_data.get_max_len() > MAX_NFT_IDENTIFIERS { - return Err(CheckErrorKind::MaxIdentifierLengthExceeded( + return Err(StaticCheckErrorKind::MaxIdentifierLengthExceeded( MAX_NFT_IDENTIFIERS, list_data.get_max_len(), ) @@ -288,7 +294,7 @@ fn check_allowance_with_stacking( checker.type_check_expects( args.first() - .ok_or(CheckErrorKind::CheckerImplementationFailure)?, + .ok_or(StaticCheckErrorKind::CheckerImplementationFailure)?, context, &TypeSignature::UIntType, )?; 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 2b09b450d3f..8ce09650793 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"); } @@ -3399,7 +3398,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), )), @@ -3407,7 +3406,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), )), @@ -3415,7 +3414,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), )), @@ -3423,7 +3422,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(), @@ -3433,7 +3432,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()), @@ -3443,7 +3442,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()), @@ -3453,7 +3452,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(), @@ -3463,7 +3462,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![ @@ -3478,7 +3477,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()), )), @@ -3486,7 +3485,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) @@ -3503,7 +3502,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(), )) }; diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/conversions.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/conversions.rs index b889bcc53ff..5cc016fafe4 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/tests/conversions.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/conversions.rs @@ -12,8 +12,7 @@ // // You should have received a copy of the GNU General Public License // along with this program. If not, see . - -use clarity_types::errors::CheckErrorKind; +use clarity_types::errors::analysis::StaticCheckErrorKind; use clarity_types::types::{ BufferLength, ListTypeData, SequenceSubtype, StringSubtype, TypeSignature, MAX_TO_ASCII_BUFFER_LEN, @@ -99,7 +98,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(), @@ -125,7 +124,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()), @@ -135,7 +134,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(), @@ -145,7 +144,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![ @@ -160,7 +159,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()), )), @@ -168,7 +167,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) @@ -185,7 +184,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 3dc3148ba01..f3c6143b3a7 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 @@ -22,7 +22,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::type_checker::v2_1::{MAX_FUNCTION_PARAMETERS, MAX_TRAIT_METHODS}; use crate::vm::analysis::types::ContractAnalysis; @@ -105,26 +105,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, ), ]; @@ -201,26 +201,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, ), ]; @@ -279,10 +279,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()) { @@ -324,7 +324,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 { @@ -345,10 +345,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"), @@ -405,15 +405,15 @@ fn test_define_functions(#[case] version: ClarityVersion, #[case] epoch: StacksE ), ]; let bad_expected = [ - CheckErrorKind::TooManyFunctionParameters( + StaticCheckErrorKind::TooManyFunctionParameters( MAX_FUNCTION_PARAMETERS + 1, MAX_FUNCTION_PARAMETERS, ), - CheckErrorKind::TooManyFunctionParameters( + StaticCheckErrorKind::TooManyFunctionParameters( MAX_FUNCTION_PARAMETERS + 1, MAX_FUNCTION_PARAMETERS, ), - CheckErrorKind::TooManyFunctionParameters( + StaticCheckErrorKind::TooManyFunctionParameters( MAX_FUNCTION_PARAMETERS + 1, MAX_FUNCTION_PARAMETERS, ), @@ -453,11 +453,11 @@ fn test_define_trait(#[case] version: ClarityVersion, #[case] epoch: StacksEpoch "(define-trait trait-1 ((get-1 (uint) (response uint uint)) u1))", ]; let bad_expected = [ - CheckErrorKind::InvalidTypeDescription, - CheckErrorKind::DefineTraitBadSignature, - CheckErrorKind::DefineTraitBadSignature, - CheckErrorKind::InvalidTypeDescription, - CheckErrorKind::DefineTraitBadSignature, + StaticCheckErrorKind::InvalidTypeDescription, + StaticCheckErrorKind::DefineTraitBadSignature, + StaticCheckErrorKind::DefineTraitBadSignature, + StaticCheckErrorKind::InvalidTypeDescription, + StaticCheckErrorKind::DefineTraitBadSignature, ]; for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) { @@ -505,8 +505,8 @@ fn test_define_trait(#[case] version: ClarityVersion, #[case] epoch: StacksEpoch ), ]; let bad_expected = [ - CheckErrorKind::TraitTooManyMethods(MAX_TRAIT_METHODS + 1, MAX_TRAIT_METHODS), - CheckErrorKind::TooManyFunctionParameters( + StaticCheckErrorKind::TraitTooManyMethods(MAX_TRAIT_METHODS + 1, MAX_TRAIT_METHODS), + StaticCheckErrorKind::TooManyFunctionParameters( MAX_FUNCTION_PARAMETERS + 1, MAX_FUNCTION_PARAMETERS, ), @@ -601,42 +601,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()) { @@ -665,7 +665,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))), )]; @@ -733,7 +733,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, @@ -741,92 +741,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))) @@ -834,7 +843,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(), @@ -849,7 +858,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(), @@ -859,23 +868,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), ), ]; @@ -898,14 +907,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), ), ]; @@ -939,7 +948,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() { @@ -986,23 +995,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()) { @@ -1027,12 +1036,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()) { @@ -1093,14 +1102,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(_, _) )); } } @@ -1123,10 +1132,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()) { @@ -1159,9 +1168,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), ), @@ -1234,47 +1243,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()) { @@ -1318,16 +1327,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()) { @@ -1359,12 +1368,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, @@ -1402,9 +1411,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()) { @@ -1468,23 +1477,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()) { @@ -1525,20 +1534,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()) { @@ -1606,9 +1615,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); @@ -1652,9 +1661,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); @@ -1692,9 +1701,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); @@ -1723,9 +1732,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); @@ -1757,9 +1766,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); @@ -1788,9 +1797,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); @@ -1836,17 +1845,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(), ))), @@ -1894,20 +1903,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))), ), @@ -1952,20 +1961,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)))), ), @@ -2010,20 +2019,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)))), ), @@ -2052,9 +2061,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); @@ -2137,8 +2146,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()) { @@ -2162,7 +2171,7 @@ fn test_empty_tuple_should_fail() { assert_eq!( *mem_type_check(contract_src).unwrap_err().err, - CheckErrorKind::EmptyTuplesNotAllowed, + StaticCheckErrorKind::EmptyTuplesNotAllowed, ); } @@ -2242,9 +2251,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()) { @@ -2276,9 +2285,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(), ))), @@ -2286,7 +2295,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(), ))), @@ -2350,37 +2359,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, @@ -2389,16 +2398,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, @@ -2407,7 +2416,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, @@ -2462,7 +2471,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, @@ -2470,8 +2479,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()) { @@ -2589,7 +2598,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) } @@ -2599,7 +2608,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) } @@ -2708,7 +2717,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(_, _) )); } @@ -2719,7 +2728,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] @@ -2735,7 +2744,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] @@ -2747,7 +2756,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] @@ -2762,7 +2774,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] @@ -2775,7 +2787,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] @@ -2786,7 +2801,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] @@ -2797,7 +2815,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] @@ -2809,7 +2827,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] @@ -2822,7 +2840,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] @@ -2834,7 +2852,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] @@ -3034,7 +3052,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(_, _))); } } @@ -3049,7 +3067,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(_) + )); } } @@ -3091,7 +3112,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(_, _))); } } @@ -3109,7 +3130,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(_) + )); } } @@ -3149,7 +3173,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(_, _))); } } @@ -3164,7 +3188,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(_) + )); } } @@ -3208,7 +3235,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(_, _))); } } @@ -3226,7 +3253,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(_) + )); } } @@ -3342,7 +3372,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] @@ -3351,7 +3381,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] @@ -3360,7 +3390,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] @@ -3404,7 +3434,7 @@ fn test_comparison_types() { r#"(>= "aaa" "aaa" "aaa")"#, ]; let bad_expected = [ - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::UnionTypeError( vec![ IntType, UIntType, @@ -3418,7 +3448,7 @@ fn test_comparison_types() { ], Box::new(PrincipalType), ), - CheckErrorKind::UnionTypeError( + StaticCheckErrorKind::UnionTypeError( vec![ IntType, UIntType, @@ -3434,7 +3464,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(), )))), @@ -3442,7 +3472,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(), )))), @@ -3450,7 +3480,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(), ))), @@ -3458,7 +3488,7 @@ fn test_comparison_types() { StringUTF8Length::try_from(3u32).unwrap(), )))), ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(SequenceType(BufferType( BufferLength::try_from(2_u32).unwrap(), ))), @@ -3466,9 +3496,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()) { @@ -3497,9 +3527,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), ), @@ -3553,17 +3583,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), ), @@ -3571,7 +3601,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(), @@ -3581,12 +3611,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())))), ), @@ -3594,7 +3627,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), ), @@ -3602,7 +3635,7 @@ fn test_principal_construct() { // too many arguments ( r#"(principal-construct? 0x22 0xfa6bf38ed557fe417333710d6033e9419391a320 "foo" "bar")"#, - CheckErrorKind::RequiresAtMostArguments(3, 4), + StaticCheckErrorKind::RequiresAtMostArguments(3, 4), ), ]; @@ -3656,7 +3689,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(), @@ -3822,15 +3855,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( @@ -3842,15 +3875,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()), ), @@ -3962,17 +3995,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()) { @@ -3996,9 +4029,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()) { @@ -4023,21 +4056,21 @@ fn test_secp256k1_recover_type_check() { let bad_cases = [ ( "(secp256k1-recover?)".to_string(), - CheckErrorKind::IncorrectArgumentCount(2, 0), + StaticCheckErrorKind::IncorrectArgumentCount(2, 0), ), ( format!( "(secp256k1-recover? {} {} {})", SECP256_MESSAGE_HASH, SECP256K1_SIGNATURE, SECP256K1_PUBLIC_KEY ), - CheckErrorKind::IncorrectArgumentCount(2, 3), + StaticCheckErrorKind::IncorrectArgumentCount(2, 3), ), ( format!( "(secp256k1-recover? {} {})", SECP256K1_SIGNATURE, SECP256K1_SIGNATURE ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_32), Box::new(TypeSignature::BUFFER_65), ), @@ -4047,7 +4080,7 @@ fn test_secp256k1_recover_type_check() { "(secp256k1-recover? {} {})", SECP256_MESSAGE_HASH, SECP256K1_SIGNATURE_TOO_LONG ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_65), Box::new(buffer_66_type.clone()), ), @@ -4081,21 +4114,21 @@ fn test_secp256k1_verify_type_check() { let bad_cases = [ ( "(secp256k1-verify)".to_string(), - CheckErrorKind::IncorrectArgumentCount(3, 0), + StaticCheckErrorKind::IncorrectArgumentCount(3, 0), ), ( format!( "(secp256k1-verify {} {})", SECP256_MESSAGE_HASH, SECP256K1_SIGNATURE ), - CheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), ), ( format!( "(secp256k1-verify {} {} {})", SECP256K1_SIGNATURE, SECP256K1_SIGNATURE, SECP256K1_PUBLIC_KEY ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_32), Box::new(TypeSignature::BUFFER_65), ), @@ -4105,7 +4138,7 @@ fn test_secp256k1_verify_type_check() { "(secp256k1-verify {} {} {})", SECP256_MESSAGE_HASH, SECP256K1_SIGNATURE_TOO_LONG, SECP256K1_PUBLIC_KEY ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_65), Box::new(buffer_66_type.clone()), ), @@ -4115,7 +4148,7 @@ fn test_secp256k1_verify_type_check() { "(secp256k1-verify {} {} {})", SECP256_MESSAGE_HASH, SECP256K1_SIGNATURE, SECP256K1_SIGNATURE ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_33), Box::new(TypeSignature::BUFFER_65), ), @@ -4144,21 +4177,21 @@ fn test_secp256r1_verify_type_check() { let bad_cases = [ ( "(secp256r1-verify)".to_string(), - CheckErrorKind::IncorrectArgumentCount(3, 0), + StaticCheckErrorKind::IncorrectArgumentCount(3, 0), ), ( format!( "(secp256r1-verify {} {})", SECP256_MESSAGE_HASH, SECP256R1_SIGNATURE ), - CheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), ), ( format!( "(secp256r1-verify {} {} {})", SECP256K1_SIGNATURE, SECP256R1_SIGNATURE, SECP256K1_PUBLIC_KEY ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_32), Box::new(TypeSignature::BUFFER_65), ), @@ -4168,7 +4201,7 @@ fn test_secp256r1_verify_type_check() { "(secp256r1-verify {} {} {})", SECP256_MESSAGE_HASH, SECP256K1_SIGNATURE, SECP256K1_PUBLIC_KEY ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_64), Box::new(TypeSignature::BUFFER_65), ), @@ -4178,7 +4211,7 @@ fn test_secp256r1_verify_type_check() { "(secp256r1-verify {} {} {})", SECP256_MESSAGE_HASH, SECP256R1_SIGNATURE, SECP256K1_SIGNATURE ), - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( Box::new(TypeSignature::BUFFER_33), Box::new(TypeSignature::BUFFER_65), ), diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/post_conditions.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/post_conditions.rs index 85ff9b1fe2f..ad41e160f72 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/tests/post_conditions.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/post_conditions.rs @@ -13,7 +13,7 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use clarity_types::errors::CheckErrorKind; +use clarity_types::errors::analysis::StaticCheckErrorKind; use clarity_types::representations::MAX_STRING_LEN; use clarity_types::types::TypeSignature; use stacks_common::types::StacksEpochId; @@ -70,22 +70,22 @@ fn test_restrict_assets(#[case] version: ClarityVersion, #[case] epoch: StacksEp // with-all-assets-unsafe ( "(restrict-assets? tx-sender ((with-all-assets-unsafe)) true)", - CheckErrorKind::WithAllAllowanceNotAllowed, + StaticCheckErrorKind::WithAllAllowanceNotAllowed, ), // no asset-owner ( "(restrict-assets? ((with-stx u5000)) true)", - CheckErrorKind::RequiresAtLeastArguments(3, 2), + StaticCheckErrorKind::RequiresAtLeastArguments(3, 2), ), // no asset-owner, 3 args ( "(restrict-assets? ((with-stx u5000)) true true)", - CheckErrorKind::NonFunctionApplication, + StaticCheckErrorKind::NonFunctionApplication, ), // bad asset-owner type ( "(restrict-assets? u100 ((with-stx u5000)) true)", - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::PrincipalType.into(), TypeSignature::UIntType.into(), ), @@ -93,57 +93,57 @@ fn test_restrict_assets(#[case] version: ClarityVersion, #[case] epoch: StacksEp // no allowances ( "(restrict-assets? tx-sender true)", - CheckErrorKind::RequiresAtLeastArguments(3, 2), + StaticCheckErrorKind::RequiresAtLeastArguments(3, 2), ), // allowance not in list ( "(restrict-assets? tx-sender (with-stx u1) true)", - CheckErrorKind::ExpectedListApplication, + StaticCheckErrorKind::ExpectedListApplication, ), // other value in place of allowance list ( "(restrict-assets? tx-sender u1 true)", - CheckErrorKind::ExpectedListOfAllowances("restrict-assets?".into(), 2), + StaticCheckErrorKind::ExpectedListOfAllowances("restrict-assets?".into(), 2), ), // non-allowance in allowance list ( "(restrict-assets? tx-sender (u1) true)", - CheckErrorKind::ExpectedListApplication, + StaticCheckErrorKind::ExpectedListApplication, ), // empty list in allowance list ( "(restrict-assets? tx-sender (()) true)", - CheckErrorKind::NonFunctionApplication, + StaticCheckErrorKind::NonFunctionApplication, ), // list with literal in allowance list ( "(restrict-assets? tx-sender ((123)) true)", - CheckErrorKind::NonFunctionApplication, + StaticCheckErrorKind::NonFunctionApplication, ), // non-allowance function in allowance list ( "(restrict-assets? tx-sender ((foo)) true)", - CheckErrorKind::UnknownFunction("foo".into()), + StaticCheckErrorKind::UnknownFunction("foo".into()), ), // no body expressions ( "(restrict-assets? tx-sender ((with-stx u5000)))", - CheckErrorKind::RequiresAtLeastArguments(3, 2), + StaticCheckErrorKind::RequiresAtLeastArguments(3, 2), ), // unhandled response in only body expression ( "(restrict-assets? tx-sender ((with-stx u1000)) (err u1))", - CheckErrorKind::UncheckedIntermediaryResponses, + StaticCheckErrorKind::UncheckedIntermediaryResponses, ), // unhandled response in last body expression ( "(restrict-assets? tx-sender ((with-stx u1000)) true (err u1))", - CheckErrorKind::UncheckedIntermediaryResponses, + StaticCheckErrorKind::UncheckedIntermediaryResponses, ), // unhandled response in other body expression ( "(restrict-assets? tx-sender ((with-stx u1000)) (err u1) true)", - CheckErrorKind::UncheckedIntermediaryResponses, + StaticCheckErrorKind::UncheckedIntermediaryResponses, ), // too many allowances ( @@ -153,7 +153,7 @@ fn test_restrict_assets(#[case] version: ClarityVersion, #[case] epoch: StacksEp .collect::>() .join(" ") ), - CheckErrorKind::TooManyAllowances(MAX_ALLOWANCES, 130), + StaticCheckErrorKind::TooManyAllowances(MAX_ALLOWANCES, 130), ), // different error types thrown from body expressions ( @@ -164,7 +164,7 @@ fn test_restrict_assets(#[case] version: ClarityVersion, #[case] epoch: StacksEp u0 ) )", - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( TypeSignature::new_response(TypeSignature::NoType, TypeSignature::UIntType) .unwrap() .into(), @@ -179,7 +179,7 @@ fn test_restrict_assets(#[case] version: ClarityVersion, #[case] epoch: StacksEp if version < ClarityVersion::Clarity4 { // restrict-assets? is only available in Clarity 4+ assert_eq!( - CheckErrorKind::UnknownFunction("restrict-assets?".to_string()), + StaticCheckErrorKind::UnknownFunction("restrict-assets?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -198,7 +198,7 @@ fn test_restrict_assets(#[case] version: ClarityVersion, #[case] epoch: StacksEp if version < ClarityVersion::Clarity4 { // restrict-assets? is only available in Clarity 4+ assert_eq!( - CheckErrorKind::UnknownFunction("restrict-assets?".to_string()), + StaticCheckErrorKind::UnknownFunction("restrict-assets?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -252,67 +252,67 @@ fn test_as_contract(#[case] version: ClarityVersion, #[case] epoch: StacksEpochI // no allowances ( "(as-contract? true)", - CheckErrorKind::RequiresAtLeastArguments(2, 1), + StaticCheckErrorKind::RequiresAtLeastArguments(2, 1), ), // allowance not in list ( "(as-contract? (with-stx u1) true)", - CheckErrorKind::ExpectedListApplication, + StaticCheckErrorKind::ExpectedListApplication, ), // other value in place of allowance list ( "(as-contract? u1 true)", - CheckErrorKind::ExpectedListOfAllowances("as-contract?".into(), 1), + StaticCheckErrorKind::ExpectedListOfAllowances("as-contract?".into(), 1), ), // non-allowance in allowance list ( "(as-contract? (u1) true)", - CheckErrorKind::ExpectedListApplication, + StaticCheckErrorKind::ExpectedListApplication, ), // empty list in allowance list ( "(as-contract? (()) true)", - CheckErrorKind::NonFunctionApplication, + StaticCheckErrorKind::NonFunctionApplication, ), // list with literal in allowance list ( "(as-contract? ((123)) true)", - CheckErrorKind::NonFunctionApplication, + StaticCheckErrorKind::NonFunctionApplication, ), // non-allowance function in allowance list ( "(as-contract? ((foo)) true)", - CheckErrorKind::UnknownFunction("foo".into()), + StaticCheckErrorKind::UnknownFunction("foo".into()), ), // no body expressions ( "(as-contract? ((with-stx u5000)))", - CheckErrorKind::RequiresAtLeastArguments(2, 1), + StaticCheckErrorKind::RequiresAtLeastArguments(2, 1), ), // unhandled response in only body expression ( "(as-contract? ((with-stx u1000)) (err u1))", - CheckErrorKind::UncheckedIntermediaryResponses, + StaticCheckErrorKind::UncheckedIntermediaryResponses, ), // unhandled response in last body expression ( "(as-contract? ((with-stx u1000)) true (err u1))", - CheckErrorKind::UncheckedIntermediaryResponses, + StaticCheckErrorKind::UncheckedIntermediaryResponses, ), // unhandled response in other body expression ( "(as-contract? ((with-stx u1000)) (err u1) true)", - CheckErrorKind::UncheckedIntermediaryResponses, + StaticCheckErrorKind::UncheckedIntermediaryResponses, ), // other allowances together with with-all-assets-unsafe (first) ( "(as-contract? ((with-all-assets-unsafe) (with-stx u1000)) true)", - CheckErrorKind::WithAllAllowanceNotAlone, + StaticCheckErrorKind::WithAllAllowanceNotAlone, ), // other allowances together with with-all-assets-unsafe (second) ( "(as-contract? ((with-stx u1000) (with-all-assets-unsafe)) true)", - CheckErrorKind::WithAllAllowanceNotAlone, + StaticCheckErrorKind::WithAllAllowanceNotAlone, ), // too many allowances ( @@ -322,7 +322,7 @@ fn test_as_contract(#[case] version: ClarityVersion, #[case] epoch: StacksEpochI .collect::>() .join(" ") ), - CheckErrorKind::TooManyAllowances(MAX_ALLOWANCES, 130), + StaticCheckErrorKind::TooManyAllowances(MAX_ALLOWANCES, 130), ), // different error types thrown from body expressions ( @@ -333,7 +333,7 @@ fn test_as_contract(#[case] version: ClarityVersion, #[case] epoch: StacksEpochI u0 ) )", - CheckErrorKind::ReturnTypesMustMatch( + StaticCheckErrorKind::ReturnTypesMustMatch( TypeSignature::new_response(TypeSignature::NoType, TypeSignature::UIntType) .unwrap() .into(), @@ -348,7 +348,7 @@ fn test_as_contract(#[case] version: ClarityVersion, #[case] epoch: StacksEpochI if version < ClarityVersion::Clarity4 { // as-contract? is only available in Clarity 4+ assert_eq!( - CheckErrorKind::UnknownFunction("as-contract?".to_string()), + StaticCheckErrorKind::UnknownFunction("as-contract?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -367,7 +367,7 @@ fn test_as_contract(#[case] version: ClarityVersion, #[case] epoch: StacksEpochI if version < ClarityVersion::Clarity4 { // as-contract? is only available in Clarity 4+ assert_eq!( - CheckErrorKind::UnknownFunction("as-contract?".to_string()), + StaticCheckErrorKind::UnknownFunction("as-contract?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -416,17 +416,17 @@ fn test_with_stx_allowance(#[case] version: ClarityVersion, #[case] epoch: Stack // no arguments ( "(restrict-assets? tx-sender ((with-stx)) true)", - CheckErrorKind::IncorrectArgumentCount(1, 0), + StaticCheckErrorKind::IncorrectArgumentCount(1, 0), ), // too many arguments ( "(restrict-assets? tx-sender ((with-stx u1000 u2000)) true)", - CheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), ), // wrong type - string instead of uint ( r#"(restrict-assets? tx-sender ((with-stx "1000")) true)"#, - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::UIntType.into(), TypeSignature::new_ascii_type_checked(4).into(), ), @@ -434,7 +434,7 @@ fn test_with_stx_allowance(#[case] version: ClarityVersion, #[case] epoch: Stack // wrong type - int instead of uint ( "(restrict-assets? tx-sender ((with-stx 1000)) true)", - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::UIntType.into(), TypeSignature::IntType.into(), ), @@ -444,7 +444,7 @@ fn test_with_stx_allowance(#[case] version: ClarityVersion, #[case] epoch: Stack for (code, expected_type) in &good { if version < ClarityVersion::Clarity4 { assert_eq!( - CheckErrorKind::UnknownFunction("restrict-assets?".to_string()), + StaticCheckErrorKind::UnknownFunction("restrict-assets?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -462,7 +462,7 @@ fn test_with_stx_allowance(#[case] version: ClarityVersion, #[case] epoch: Stack for (code, expected_err) in &bad { if version < ClarityVersion::Clarity4 { assert_eq!( - CheckErrorKind::UnknownFunction("restrict-assets?".to_string()), + StaticCheckErrorKind::UnknownFunction("restrict-assets?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -526,27 +526,27 @@ fn test_with_ft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stacks // no arguments ( "(restrict-assets? tx-sender ((with-ft)) true)", - CheckErrorKind::IncorrectArgumentCount(3, 0), + StaticCheckErrorKind::IncorrectArgumentCount(3, 0), ), // one argument ( "(restrict-assets? tx-sender ((with-ft .token)) true)", - CheckErrorKind::IncorrectArgumentCount(3, 1), + StaticCheckErrorKind::IncorrectArgumentCount(3, 1), ), // two arguments ( r#"(restrict-assets? tx-sender ((with-ft .token "token-name")) true)"#, - CheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), ), // too many arguments ( r#"(restrict-assets? tx-sender ((with-ft .token "token-name" u1000 u2000)) true)"#, - CheckErrorKind::IncorrectArgumentCount(3, 4), + StaticCheckErrorKind::IncorrectArgumentCount(3, 4), ), // wrong type for contract-id - uint instead of principal ( r#"(restrict-assets? tx-sender ((with-ft u123 "token-name" u1000)) true)"#, - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::PrincipalType.into(), TypeSignature::UIntType.into(), ), @@ -554,7 +554,7 @@ fn test_with_ft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stacks // wrong type for token-name - uint instead of string ( "(restrict-assets? tx-sender ((with-ft .token u123 u1000)) true)", - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::new_ascii_type_checked(MAX_STRING_LEN as u32).into(), TypeSignature::UIntType.into(), ), @@ -562,7 +562,7 @@ fn test_with_ft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stacks // wrong type for amount - string instead of uint ( r#"(restrict-assets? tx-sender ((with-ft .token "token-name" "1000")) true)"#, - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::UIntType.into(), TypeSignature::new_ascii_type_checked(4).into(), ), @@ -570,7 +570,7 @@ fn test_with_ft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stacks // wrong type for amount - int instead of uint ( r#"(restrict-assets? tx-sender ((with-ft .token "token-name" 1000)) true)"#, - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::UIntType.into(), TypeSignature::IntType.into(), ), @@ -578,7 +578,7 @@ fn test_with_ft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stacks // too long token name (longer than 128 chars) ( "(restrict-assets? tx-sender ((with-ft .token \"this-token-name-is-way-too-long-to-be-valid-because-it-has-more-than-one-hundred-and-twenty-eight-characters-in-it-so-it-is-not-a-valid-token-name\" u1000)) true)", - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::new_ascii_type_checked(MAX_STRING_LEN as u32).into(), TypeSignature::new_ascii_type_checked(146u32).into(), ), @@ -588,7 +588,7 @@ fn test_with_ft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stacks for (code, expected_type) in &good { if version < ClarityVersion::Clarity4 { assert_eq!( - CheckErrorKind::UnknownFunction("restrict-assets?".to_string()), + StaticCheckErrorKind::UnknownFunction("restrict-assets?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -606,7 +606,7 @@ fn test_with_ft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stacks for (code, expected_err) in &bad { if version < ClarityVersion::Clarity4 { assert_eq!( - CheckErrorKind::UnknownFunction("restrict-assets?".to_string()), + StaticCheckErrorKind::UnknownFunction("restrict-assets?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -680,27 +680,27 @@ fn test_with_nft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stack // no arguments ( "(restrict-assets? tx-sender ((with-nft)) true)", - CheckErrorKind::IncorrectArgumentCount(3, 0), + StaticCheckErrorKind::IncorrectArgumentCount(3, 0), ), // one argument ( "(restrict-assets? tx-sender ((with-nft .token)) true)", - CheckErrorKind::IncorrectArgumentCount(3, 1), + StaticCheckErrorKind::IncorrectArgumentCount(3, 1), ), // two arguments ( r#"(restrict-assets? tx-sender ((with-nft .token "token-name")) true)"#, - CheckErrorKind::IncorrectArgumentCount(3, 2), + StaticCheckErrorKind::IncorrectArgumentCount(3, 2), ), // too many arguments ( r#"(restrict-assets? tx-sender ((with-nft .token "token-name" (list u123) (list u456))) true)"#, - CheckErrorKind::IncorrectArgumentCount(3, 4), + StaticCheckErrorKind::IncorrectArgumentCount(3, 4), ), // wrong type for contract-id - uint instead of principal ( r#"(restrict-assets? tx-sender ((with-nft u123 "token-name" (list u456))) true)"#, - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::PrincipalType.into(), TypeSignature::UIntType.into(), ), @@ -708,7 +708,7 @@ fn test_with_nft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stack // wrong type for token-name - uint instead of string ( "(restrict-assets? tx-sender ((with-nft .token u123 (list u456))) true)", - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::new_ascii_type_checked(MAX_STRING_LEN as u32).into(), TypeSignature::UIntType.into(), ), @@ -716,7 +716,7 @@ fn test_with_nft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stack // too long token name (longer than 128 chars) ( "(restrict-assets? tx-sender ((with-ft .token \"this-token-name-is-way-too-long-to-be-valid-because-it-has-more-than-one-hundred-and-twenty-eight-characters-in-it-so-it-is-not-a-valid-token-name\" u1000)) true)", - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::new_ascii_type_checked(MAX_STRING_LEN as u32).into(), TypeSignature::new_ascii_type_checked(146u32).into(), ), @@ -729,14 +729,14 @@ fn test_with_nft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stack .collect::>() .join(" ") ), - CheckErrorKind::MaxIdentifierLengthExceeded(MAX_NFT_IDENTIFIERS, 130), + StaticCheckErrorKind::MaxIdentifierLengthExceeded(MAX_NFT_IDENTIFIERS, 130), ), ]; for (code, expected_type) in &good { if version < ClarityVersion::Clarity4 { assert_eq!( - CheckErrorKind::UnknownFunction("restrict-assets?".to_string()), + StaticCheckErrorKind::UnknownFunction("restrict-assets?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -754,7 +754,7 @@ fn test_with_nft_allowance(#[case] version: ClarityVersion, #[case] epoch: Stack for (code, expected_err) in &bad { if version < ClarityVersion::Clarity4 { assert_eq!( - CheckErrorKind::UnknownFunction("restrict-assets?".to_string()), + StaticCheckErrorKind::UnknownFunction("restrict-assets?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -798,17 +798,17 @@ fn test_with_stacking_allowance(#[case] version: ClarityVersion, #[case] epoch: // no arguments ( "(restrict-assets? tx-sender ((with-stacking)) true)", - CheckErrorKind::IncorrectArgumentCount(1, 0), + StaticCheckErrorKind::IncorrectArgumentCount(1, 0), ), // too many arguments ( "(restrict-assets? tx-sender ((with-stacking u1000 u2000)) true)", - CheckErrorKind::IncorrectArgumentCount(1, 2), + StaticCheckErrorKind::IncorrectArgumentCount(1, 2), ), // wrong type - string instead of uint ( r#"(restrict-assets? tx-sender ((with-stacking "1000")) true)"#, - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::UIntType.into(), TypeSignature::new_ascii_type_checked(4).into(), ), @@ -816,7 +816,7 @@ fn test_with_stacking_allowance(#[case] version: ClarityVersion, #[case] epoch: // wrong type - int instead of uint ( "(restrict-assets? tx-sender ((with-stacking 1000)) true)", - CheckErrorKind::TypeError( + StaticCheckErrorKind::TypeError( TypeSignature::UIntType.into(), TypeSignature::IntType.into(), ), @@ -826,7 +826,7 @@ fn test_with_stacking_allowance(#[case] version: ClarityVersion, #[case] epoch: for (code, expected_type) in &good { if version < ClarityVersion::Clarity4 { assert_eq!( - CheckErrorKind::UnknownFunction("restrict-assets?".to_string()), + StaticCheckErrorKind::UnknownFunction("restrict-assets?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -844,7 +844,7 @@ fn test_with_stacking_allowance(#[case] version: ClarityVersion, #[case] epoch: for (code, expected_err) in &bad { if version < ClarityVersion::Clarity4 { assert_eq!( - CheckErrorKind::UnknownFunction("restrict-assets?".to_string()), + StaticCheckErrorKind::UnknownFunction("restrict-assets?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -881,19 +881,19 @@ fn test_with_all_assets_unsafe_allowance( // with-all-assets-unsafe in restrict-assets? (not allowed) ( "(restrict-assets? tx-sender ((with-all-assets-unsafe)) true)", - CheckErrorKind::WithAllAllowanceNotAllowed, + StaticCheckErrorKind::WithAllAllowanceNotAllowed, ), // with-all-assets-unsafe with arguments (should take 0) ( "(restrict-assets? tx-sender ((with-all-assets-unsafe u123)) true)", - CheckErrorKind::IncorrectArgumentCount(0, 1), + StaticCheckErrorKind::IncorrectArgumentCount(0, 1), ), ]; for (code, expected_type) in &good { if version < ClarityVersion::Clarity4 { assert_eq!( - CheckErrorKind::UnknownFunction("as-contract?".to_string()), + StaticCheckErrorKind::UnknownFunction("as-contract?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, @@ -911,7 +911,7 @@ fn test_with_all_assets_unsafe_allowance( for (code, expected_err) in &bad { if version < ClarityVersion::Clarity4 { assert_eq!( - CheckErrorKind::UnknownFunction("restrict-assets?".to_string()), + StaticCheckErrorKind::UnknownFunction("restrict-assets?".to_string()), *type_check_helper_version(code, version, epoch) .unwrap_err() .err, 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 0bbd6a7d0a6..7cdb1f2a016 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}; @@ -79,14 +81,14 @@ impl std::error::Error for ClarityError { 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), @@ -297,13 +299,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 e5d78e24f3b..7dd07dcb4fa 100644 --- a/clarity/src/vm/errors.rs +++ b/clarity/src/vm/errors.rs @@ -20,7 +20,8 @@ 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, + CommonCheckErrorKind, StaticCheckError, StaticCheckErrorKind, SyntaxBindingError, + SyntaxBindingErrorType, }; #[cfg(test)] diff --git a/clarity/src/vm/functions/define.rs b/clarity/src/vm/functions/define.rs index b692d584217..b68e371411d 100644 --- a/clarity/src/vm/functions/define.rs +++ b/clarity/src/vm/functions/define.rs @@ -19,8 +19,8 @@ use std::collections::BTreeMap; use crate::vm::callables::{DefineType, DefinedFunction}; use crate::vm::contexts::{ContractContext, Environment, LocalContext}; use crate::vm::errors::{ - check_argument_count, check_arguments_at_least, CheckErrorKind, SyntaxBindingErrorType, - VmExecutionError, + check_argument_count, check_arguments_at_least, CheckErrorKind, CommonCheckErrorKind, + SyntaxBindingErrorType, VmExecutionError, }; use crate::vm::eval; use crate::vm::representations::SymbolicExpressionType::Field; @@ -291,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), @@ -299,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], @@ -309,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], @@ -319,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], @@ -329,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], @@ -337,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], @@ -345,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 { @@ -354,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], @@ -368,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], @@ -377,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..], @@ -385,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 => { @@ -400,7 +414,7 @@ impl<'a> DefineFunctionsParsed<'a> { Field(ref field) => DefineFunctionsParsed::ImplTrait { trait_identifier: field, }, - _ => return Err(CheckErrorKind::ExpectedTraitIdentifier), + _ => return Err(CommonCheckErrorKind::ExpectedTraitIdentifier), } } }; diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs index 7877a0dd34f..1c71140fda1 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}; @@ -711,7 +712,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 e2672a2b2cc..4f9dca8740a 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, StaticCheckErrorKind}; pub use clarity_types::types::signatures::{ AssetIdentifier, BufferLength, CallableSubtype, ListTypeData, SequenceSubtype, StringSubtype, StringUTF8Length, TupleTypeSignature, TypeSignature, @@ -27,7 +28,7 @@ use stacks_common::types::StacksEpochId; use self::TypeSignature::SequenceType; use crate::vm::analysis::type_checker::v2_1::{MAX_FUNCTION_PARAMETERS, MAX_TRAIT_METHODS}; 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, }; @@ -163,59 +164,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())), } } @@ -225,18 +226,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) } } @@ -246,8 +248,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, @@ -261,15 +263,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) } } @@ -277,16 +279,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) } } @@ -294,16 +296,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) } } @@ -311,9 +313,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)?; @@ -324,20 +326,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 { @@ -348,7 +351,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), @@ -362,10 +365,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) @@ -390,7 +393,7 @@ impl TypeSignatureExt for TypeSignature { )), } } - _ => Err(CheckErrorKind::InvalidTypeDescription), + _ => Err(CommonCheckErrorKind::InvalidTypeDescription), } } @@ -399,17 +402,17 @@ 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)?; // Check the method count against the maximum allowed if epoch.limits_parameter_and_method_count() && functions_types.len() > MAX_TRAIT_METHODS { - return Err(CheckErrorKind::TraitTooManyMethods( + return Err(CommonCheckErrorKind::TraitTooManyMethods( functions_types.len(), MAX_TRAIT_METHODS, )); @@ -417,7 +420,7 @@ impl TypeSignatureExt for TypeSignature { // Check the method count against the maximum allowed if epoch.limits_parameter_and_method_count() && functions_types.len() > MAX_TRAIT_METHODS { - return Err(CheckErrorKind::TraitTooManyMethods( + return Err(CommonCheckErrorKind::TraitTooManyMethods( functions_types.len(), MAX_TRAIT_METHODS, )); @@ -426,26 +429,26 @@ impl TypeSignatureExt for TypeSignature { 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)?; // Check the argument count against the maximum allowed if epoch.limits_parameter_and_method_count() && fn_args_exprs.len() > MAX_FUNCTION_PARAMETERS { - return Err(CheckErrorKind::TooManyFunctionParameters( + return Err(CommonCheckErrorKind::TooManyFunctionParameters( fn_args_exprs.len(), MAX_FUNCTION_PARAMETERS, )); @@ -454,15 +457,15 @@ impl TypeSignatureExt for TypeSignature { 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 @@ -476,7 +479,7 @@ impl TypeSignatureExt for TypeSignature { .is_some() && clarity_version >= ClarityVersion::Clarity2 { - return Err(CheckErrorKind::DefineTraitDuplicateMethod( + return Err(CommonCheckErrorKind::DefineTraitDuplicateMethod( fn_name.to_string(), )); } @@ -501,7 +504,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 = @@ -512,11 +515,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(|_| StaticCheckErrorKind::CostOverflow)?; } Ok(function_type_size) } @@ -525,7 +529,7 @@ impl FunctionSignature { &self, epoch: &StacksEpochId, args: Vec, - ) -> Result { + ) -> Result { if args.len() != self.args.len() { return Ok(false); } @@ -574,7 +578,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: @@ -583,14 +587,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, )), @@ -609,7 +613,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))| { @@ -617,7 +621,7 @@ where .match_atom() .ok_or_else(|| { ( - CheckErrorKind::BadSyntaxBinding(SyntaxBindingError::NotAtom( + CommonCheckErrorKind::BadSyntaxBinding(SyntaxBindingError::NotAtom( binding_error_type, i, )), @@ -642,13 +646,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; @@ -663,7 +668,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)] @@ -691,7 +698,7 @@ mod test { assert_eq!( TupleTypeSignature::try_from(keys).unwrap_err(), - ValueTooLarge + CommonCheckErrorKind::ValueTooLarge ); } diff --git a/contrib/clarity-cli/src/lib.rs b/contrib/clarity-cli/src/lib.rs index b029bb03bd2..1b9212a011f 100644 --- a/contrib/clarity-cli/src/lib.rs +++ b/contrib/clarity-cli/src/lib.rs @@ -21,7 +21,21 @@ use std::io::{Read, Write}; use std::path::PathBuf; use std::{fs, io}; +use clarity::vm::analysis::contract_interface_builder::build_contract_interface; +use clarity::vm::analysis::{AnalysisDatabase, ContractAnalysis}; +use clarity::vm::ast::build_ast; +use clarity::vm::contexts::{AssetMap, GlobalContext, OwnedEnvironment}; +use clarity::vm::costs::{ExecutionCost, LimitedCostTracker}; use clarity::vm::coverage::CoverageReporter; +use clarity::vm::database::{ + BurnStateDB, ClarityDatabase, HeadersDB, NULL_BURN_STATE_DB, STXBalance, +}; +use clarity::vm::errors::{RuntimeError, StaticCheckError, VmExecutionError}; +use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; +use clarity::vm::{ + ClarityVersion, ContractContext, ContractName, SymbolicExpression, Value, analysis, ast, + eval_all, +}; use lazy_static::lazy_static; use rand::Rng; use rusqlite::{Connection, OpenFlags}; @@ -44,21 +58,6 @@ use stackslib::chainstate::stacks::boot::{ POX_2_MAINNET_CODE, POX_2_TESTNET_CODE, }; use stackslib::chainstate::stacks::index::ClarityMarfTrieId; -use stackslib::clarity::vm::analysis::contract_interface_builder::build_contract_interface; -use stackslib::clarity::vm::analysis::errors::StaticCheckError; -use stackslib::clarity::vm::analysis::{AnalysisDatabase, ContractAnalysis}; -use stackslib::clarity::vm::ast::build_ast; -use stackslib::clarity::vm::contexts::{AssetMap, GlobalContext, OwnedEnvironment}; -use stackslib::clarity::vm::costs::{ExecutionCost, LimitedCostTracker}; -use stackslib::clarity::vm::database::{ - BurnStateDB, ClarityDatabase, HeadersDB, NULL_BURN_STATE_DB, STXBalance, -}; -use stackslib::clarity::vm::errors::{RuntimeError, VmExecutionError}; -use stackslib::clarity::vm::types::{PrincipalData, QualifiedContractIdentifier}; -use stackslib::clarity::vm::{ - ClarityVersion, ContractContext, ContractName, SymbolicExpression, Value, analysis, ast, - eval_all, -}; use stackslib::clarity_vm::clarity::{ClarityMarfStore, ClarityMarfStoreTransaction}; use stackslib::clarity_vm::database::MemoryBackingStore; use stackslib::clarity_vm::database::marf::{MarfedKV, PersistentWritableMarfStore}; diff --git a/stackslib/src/chainstate/stacks/boot/contract_tests.rs b/stackslib/src/chainstate/stacks/boot/contract_tests.rs index d7b9302de7b..61b8bcc4b11 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/consensus.rs b/stackslib/src/chainstate/tests/consensus.rs index 19d01da92a3..12604542098 100644 --- a/stackslib/src/chainstate/tests/consensus.rs +++ b/stackslib/src/chainstate/tests/consensus.rs @@ -23,7 +23,7 @@ use clarity::types::{EpochList, StacksEpoch, StacksEpochId}; use clarity::util::hash::{Hash160, MerkleTree, Sha512Trunc256Sum}; use clarity::util::secp256k1::MessageSignature; use clarity::vm::costs::ExecutionCost; -use clarity::vm::types::PrincipalData; +use clarity::vm::types::{PrincipalData, ResponseData}; use clarity::vm::{ClarityVersion, Value as ClarityValue}; use serde::{Deserialize, Serialize, Serializer}; use stacks_common::bitvec::BitVec; @@ -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,8 @@ 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 + /// * `exclude_clarity_versions` - List of Clarity versions to exclude from testing. For each epoch to test, at least a clarity version must available. + /// * `setup_contracts` - Contracts that must be deployed before epoch-specific logic runs /// /// # Panics /// @@ -1034,16 +1038,33 @@ impl ContractConsensusTest<'_> { contract_code: &str, function_name: &str, function_args: &[ClarityValue], + exclude_clarity_versions: &[ClarityVersion], + setup_contracts: &[SetupContract], ) -> Self { assert!( !deploy_epochs.is_empty(), "At least one deploy epoch is required" ); + for epoch in deploy_epochs { + let supported_versions = clarity_versions_for_epoch(*epoch); + assert!( + supported_versions + .iter() + .any(|version| !exclude_clarity_versions.contains(version)), + "Epoch {epoch} does not have any Clarity versions available after applying exclusions", + ); + } let min_deploy_epoch = deploy_epochs.iter().min().unwrap(); assert!( call_epochs.iter().all(|e| e >= min_deploy_epoch), "All call epochs must be >= the minimum deploy epoch" ); + assert!( + setup_contracts + .iter() + .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" + ); // Build epoch_blocks map based on deploy and call epochs let mut num_blocks_per_epoch: HashMap = HashMap::new(); @@ -1051,17 +1072,55 @@ 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 clarity_versions_per_epoch = clarity_versions_for_epoch(*epoch); + // Exclude the clarity versions that are in the exclude_clarity_versions list. + let clarity_versions = clarity_versions_per_epoch + .iter() + .filter(|v| !exclude_clarity_versions.contains(v)); + let epoch_name = format!("Epoch{}", epoch.to_string().replace('.', "_")); // Each deployment is a seperate TestBlock @@ -1102,6 +1161,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 +1194,62 @@ impl ContractConsensusTest<'_> { result } + /// Deploys prerequisite contracts scheduled for the given epoch. + /// Panics if the deployment fails. + fn deploy_setup_contracts(&mut self, epoch: StacksEpochId) { + let Some(contracts) = self.setup_contracts_per_epoch.get(&epoch).cloned() else { + return; + }; + + let is_naka_block = epoch.uses_nakamoto_blocks(); + contracts.into_iter().for_each(|contract| { + self.chain.consume_pre_naka_prepare_phase(); + let result = self.append_tx_block( + &TestTxSpec::ContractDeploy { + sender: &FAUCET_PRIV_KEY, + name: &contract.name, + code: &contract.code, + clarity_version: contract.clarity_version, + }, + is_naka_block, + ); + match result { + ExpectedResult::Success(ref output) => { + assert_eq!( + output.transactions.len(), + 1, + "Expected 1 transaction for setup contract {}, got {}", + contract.name, + output.transactions.len() + ); + let tx_output = &output.transactions.first().unwrap(); + assert_eq!( + tx_output.return_type, + ClarityValue::Response(ResponseData { + committed: true, + data: Box::new(ClarityValue::Bool(true)), + }), + "Setup contract {} failed to deploy: got {:?}", + contract.name, + tx_output + ); + assert!( + tx_output.vm_error.is_none(), + "Expected no VM error for setup contract {}, got {:?}", + contract.name, + tx_output.vm_error + ); + } + ExpectedResult::Failure(error) => { + panic!( + "Setup contract {} deployment failed: {error:?}", + contract.name + ); + } + } + }); + } + /// Deploys all contract versions scheduled for the given epoch. /// /// For each Clarity version supported in the epoch: @@ -1251,6 +1367,9 @@ impl ContractConsensusTest<'_> { .test_chainstate .advance_into_epoch(&private_key, epoch); + // Differently from the deploy_contracts and call_contracts functions, setup contracts are expected to succeed. + // Their receipt is not relevant to the test. + self.deploy_setup_contracts(epoch); results.extend(self.deploy_contracts(epoch)); results.extend(self.call_contracts(epoch)); } @@ -1318,7 +1437,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) @@ -1464,8 +1583,10 @@ 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`]. +/// * `clarity_versions` — *(optional)* Clarity versions to test. For each epoch to test, at least one of the clarity versions must be supported. Defaults to all Clarity versions. +/// * `setup_contracts` — *(optional)* Slice of [`SetupContract`] values to deploy once before the main contract logic. /// /// # Example /// @@ -1474,9 +1595,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 +1615,8 @@ macro_rules! contract_call_consensus_test { function_args: $function_args:expr, $(deploy_epochs: $deploy_epochs:expr,)? $(call_epochs: $call_epochs:expr,)? + $(exclude_clarity_versions: $exclude_clarity_versions:expr,)? + $(setup_contracts: $setup_contracts:expr,)? ) => { { // Handle deploy_epochs parameter (default to all epochs >= 2.0 if not provided) @@ -1497,6 +1626,10 @@ 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 exclude_clarity_versions: &[clarity::vm::ClarityVersion] = &[]; + $(let exclude_clarity_versions = $exclude_clarity_versions;)? let contract_test = $crate::chainstate::tests::consensus::ContractConsensusTest::new( function_name!(), vec![], @@ -1506,6 +1639,8 @@ macro_rules! contract_call_consensus_test { $contract_code, $function_name, $function_args, + exclude_clarity_versions, + setup_contracts, ); let result = contract_test.run(); insta::assert_ron_snapshot!(result); @@ -1532,6 +1667,8 @@ 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`]. +/// * `exclude_clarity_versions` — *(optional)* Clarity versions to exclude from testing. For each epoch to test, at least one of the clarity versions must be supported. Defaults to no Clarity versions. +/// * `setup_contracts` — *(optional)* Slice of [`SetupContract`] values to deploy before the main contract. /// /// # Example /// @@ -1546,34 +1683,74 @@ 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, - ) => { - 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, + $(deploy_epochs: $deploy_epochs:expr,)? + $(exclude_clarity_versions: $exclude_clarity_versions:expr,)? + $(setup_contracts: $setup_contracts: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 + $(exclude_clarity_versions: $exclude_clarity_versions,)? + $(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; diff --git a/stackslib/src/chainstate/tests/mod.rs b/stackslib/src/chainstate/tests/mod.rs index adef63d14d9..cedefae82de 100644 --- a/stackslib/src/chainstate/tests/mod.rs +++ b/stackslib/src/chainstate/tests/mod.rs @@ -14,6 +14,7 @@ // along with this program. If not, see . pub mod consensus; mod parse_tests; +mod runtime_analysis_tests; mod static_analysis_tests; use std::fs; 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..64bf55eb348 --- /dev/null +++ b/stackslib/src/chainstate/tests/runtime_analysis_tests.rs @@ -0,0 +1,521 @@ +// 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. + +use std::collections::HashMap; + +#[allow(unused_imports)] +use clarity::vm::analysis::CheckErrorKind; +use clarity::vm::types::{QualifiedContractIdentifier, MAX_TYPE_DEPTH}; +use clarity::vm::{ClarityVersion, Value as ClarityValue}; + +use crate::chainstate::tests::consensus::{ + 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; + +/// 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 +/// the read-count limit in [`BLOCK_LIMIT_MAINNET_21`]. +/// Outcome: block rejected. +#[test] +fn check_error_cost_balance_exceeded_cdeploy() { + 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) + ), + ); +} + +/// CheckErrorKind: [`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!( + 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_cdeploy() { + 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_cdeploy() { + 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)))", + ); +} + +/// 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: " + (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)", + exclude_clarity_versions: &[ClarityVersion::Clarity1], + setup_contracts: &[contract_1, contract_2], + ); +} + +/// 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))", + exclude_clarity_versions: &[ClarityVersion::Clarity1, ClarityVersion::Clarity2, ClarityVersion::Clarity3], + setup_contracts: &[contract_1], + ); +} + +// pub enum CheckErrorKind { +// CostOverflow, // Unreachable: should exceed u64 +// CostBalanceExceeded(ExecutionCost, ExecutionCost), [`check_error_cost_balance_exceeded_cdeploy`] +// MemoryBalanceExceeded(u64, u64), +// CostComputationFailed(String), // Unreachable +// ExecutionTimeExpired, +// 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, // 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), 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, // 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), +// 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), [`check_error_kind_return_types_must_match_ccall`] +// CircularReference(Vec), +// NoSuchContract(String), [`check_error_kind_no_such_contract_ccall`] +// NoSuchPublicFunction(String, String), +// PublicFunctionNotReadOnly(String, String), +// ContractAlreadyExists(String), +// ContractCallExpectName, [`check_error_kind_contract_call_expect_name_cdeploy`] +// NoSuchBurnBlockInfoProperty(String), +// NoSuchStacksBlockInfoProperty(String), +// GetBlockInfoExpectPropertyName, +// GetStacksBlockInfoExpectPropertyName, +// GetTenureInfoExpectPropertyName, +// NameAlreadyUsed(String), [`check_error_kind_name_already_used_cdeploy`] +// NonFunctionApplication, +// ExpectedListApplication, +// ExpectedSequence(Box), +// BadLetSyntax, +// BadSyntaxBinding(SyntaxBindingError), +// UndefinedFunction(String), // Unreachable? Wasn't able to trigger this error during contract initialization. +// UndefinedVariable(String), +// RequiresAtLeastArguments(usize, usize), +// RequiresAtMostArguments(usize, usize), +// IncorrectArgumentCount(usize, usize), [`check_error_kind_incorrect_argument_count_ccall`] +// TooManyFunctionParameters(usize, usize), +// TraitReferenceUnknown(String), +// TraitMethodUnknown(String, String), +// ExpectedTraitIdentifier, // Unreachable: callable trait values always carry their trait id after sanitization +// 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)], + ); +} + +/// 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: " + (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))", + function_name: "trigger-error", + function_args: &[], + deploy_epochs: EPOCHS_TO_TEST, + call_epochs: EPOCHS_TO_TEST, + exclude_clarity_versions: &[ClarityVersion::Clarity1], + 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: &[], + ); +} + +/// 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], + ); +} + +/// 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); +} + +/// 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: &[], + 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_cost_balance_exceeded_cdeploy.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_cost_balance_exceeded_cdeploy.snap new file mode 100644 index 00000000000..d925804b9cb --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_cost_balance_exceeded_cdeploy.snap @@ -0,0 +1,22 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Failure(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block 22f35565535e563262e98f8c1c79886cdd79892342d839082072861db2108303: 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(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block a98110cf4eec61626afbd0964f775f1828046f87279c8e49d54752a6bbcb2561: 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(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block b01f450c219db2ed86db7365393f2e0cd1c8a493dfd2f08293c8a71d68f5d7b5: 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(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block 2c9df7260a975f4e10ef7a17f02c3144a6fc29cffd9edb84cc0b6eb3cbcc064e: 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__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..f218aba97ed --- /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,180 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "53f9f52f7b61e13b06070417b90dd12e6f3f7f511ae8db2a5887e988d0a5f4a6", + 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: 293, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20648, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 293, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20648, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a168b5b25042be30f8748e2b93a7e87745053ffc4b29030009f4f0162929e11f", + 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: 293, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20648, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 293, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20648, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "1cd6404b761b798e09666861107191b3341afd0ea6ea8d08a0f64697d6773b0e", + 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: 293, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20648, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 293, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 20648, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "6f96dc2abd3ed8967f4979a99d7218763b6c7f097368745405592cc5b1e4318a", + 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: 420, + read_count: 3, + runtime: 654, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 420, + read_count: 3, + runtime: 654, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f7880489de41fafe855dae5698048a3cf5a547b4b715a2b0dc215f6e63dcf62f", + 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: 420, + read_count: 3, + runtime: 654, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 420, + read_count: 3, + runtime: 654, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "3231b50b32de2d15f8f84e2f8197d1ba488b1e52954ccc921b00f8faa403c1eb", + 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: 420, + read_count: 3, + runtime: 654, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 0, + write_count: 0, + read_length: 420, + read_count: 3, + 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 new file mode 100644 index 00000000000..f76ca06afcc --- /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,96 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "1db39215fa26536780994c01b73e2307740af39a2d40dedf7d2d11c86dc59390", + 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: 273, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 19904, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 273, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 19904, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "a8459c30613099d3d4859109d2be51076fb96c3b35f261d50211233795cb153f", + 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: 273, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 19904, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 273, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 19904, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "be6a784ffff194a48502f3927b37d0e9d7d1c9af9e6d9c97807bbcff97b9854f", + 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: 273, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 19904, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 273, + write_count: 2, + read_length: 9, + read_count: 3, + runtime: 19904, + ), + )), +] 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__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_name_already_used_cdeploy.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used_cdeploy.snap new file mode 100644 index 00000000000..463a6dea061 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_name_already_used_cdeploy.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "8d956af6b22c472853f432445276d339d3b57589470915f8cc1fad0bd18c925a", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity1, code_body: [..], clarity_version: Some(Clarity1))", + 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: 41, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8785, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 41, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8785, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8b7761df3fd27db36b9404e749873142c142765a57f8666182b8ff94d71f7993", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", + 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: 41, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8785, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 41, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8785, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "b7d9404c1c78ec26e95098011f38980125abedd76afd12ca0f0125ff896003d5", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity3, code_body: [..], clarity_version: Some(Clarity3))", + 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: 41, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8785, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 41, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8785, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "4b6f883ccf3127c3005bc46c750f5e31ccfcff306529eea14dab05c44b3f0568", + evaluated_epoch: Epoch33, + transactions: [ + ExpectedTransactionOutput( + tx: "SmartContract(name: name-already-used-Epoch3_3-Clarity4, code_body: [..], clarity_version: Some(Clarity4))", + 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: 41, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8785, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 41, + write_count: 2, + read_length: 1, + read_count: 1, + runtime: 8785, + ), + )), +] 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, + ), + )), +] 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..727c40f22d4 --- /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,1456 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + 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, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_signature_too_deep_cdeploy.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_signature_too_deep_cdeploy.snap new file mode 100644 index 00000000000..3eee6cf6c93 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_type_signature_too_deep_cdeploy.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "487cba889edf498ee41d3d2ae5afee48cfeb0330dadb6483c128f33e7edcdae5", + 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: "9942de61e187a807462e98216f9210c148444f92756b9edd7a10986cb8cd51fe", + 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: "6ba7c17beab0113cbf7a81572464787b09cb21e468c68fd351f57171104107d1", + 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: "7061525d5b2de60fc6a687b9860b3d6989a638fb776fa5067824f685196c230b", + 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__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__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__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..d5531edbffa --- /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,36 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + 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, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_value_too_large_cdeploy.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_value_too_large_cdeploy.snap new file mode 100644 index 00000000000..3ddea5bf387 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__runtime_analysis_tests__check_error_kind_value_too_large_cdeploy.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/runtime_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "a4918ec1d216e0987507582a79615fc96c1d2f9e1838ae9e8c464e6525e8fea2", + 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: "f0d662c19c9f885621c5390fac9eaf6833da14dce5ee208ac7373b10b7c22a88", + 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: "667ad2ea06d28caa1deca432d86a2612bf76294d2a29e34fe2e7cba5f055951e", + 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: "d4b14c4dad73009b4a4c9057ff73daf03950752dd79619c13ec8d677e55655b3", + 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, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__error_invalid_stacks_transaction_duplicate_contract.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__error_invalid_stacks_transaction_duplicate_contract.snap new file mode 100644 index 00000000000..226aeb40413 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__error_invalid_stacks_transaction_duplicate_contract.snap @@ -0,0 +1,50 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "2d7d0b29a889aa04c79c2b794ad5ecc9e7f2ff84cdf99cf62b6ead24e11263a1", + evaluated_epoch: Epoch33, + 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(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block 6eabb186436e51578fc50c56e538cf22e2bf23d1de977132342e5b2af71ca95f: InvalidStacksTransaction(\"Duplicate contract \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-name\'\", false)", + )), + Failure(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block 470e5ea2d1c22a84f1cf95731ada6d25b9df8813f2032a6c12a8ce8118de59e0: InvalidStacksTransaction(\"Duplicate contract \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-name\'\", false)", + )), + Failure(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block 5c99bb620d852120112bb10ac3850a5a104a4ec70998867d1aaae65efe4e91c3: InvalidStacksTransaction(\"Duplicate contract \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-name\'\", false)", + )), + Failure(ExpectedFailureOutput( + evaluated_epoch: Epoch33, + error: "Invalid Stacks block 15c7400f3a64a32f4d0b8ea5b04b24bbfbfede36ce82f1fa063a40e714eff8a2: InvalidStacksTransaction(\"Duplicate contract \'ST1AW6EKPGT61SQ9FNVDS17RKNWT8ZP582VF9HSCP.contract-name\'\", false)", + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_allowance_expr_not_allowed.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_allowance_expr_not_allowed.snap new file mode 100644 index 00000000000..e0a6d2049be --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_allowance_expr_not_allowed.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "eb32387df909f2eadd0d7a1063b569712b8c3a35df55a36c76728a41d601db1b", + 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: "1deaed066e5eb990d7ada2fae15406f85c2b0bc133e187cd25fc2b0bab3fb388", + 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: "94336c26594c42dfd721c04f2e44904bc7f940ed79d569b0d530d24f6fb91ea3", + 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: "1e13666f8f12a470b8f7be27e45d126dce9abf36d398c79cfb3ffb92ced802c2", + 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__static_analysis_tests__static_check_error_at_block_closure_must_be_read_only.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_at_block_closure_must_be_read_only.snap new file mode 100644 index 00000000000..60011852cdc --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_at_block_closure_must_be_read_only.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "dfe63494e41a728bb312b67505cf3e630fa0d8c56f6a6653e979de854e75044b", + 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: "2e049a4b1768177abbc1c07666ef5c95cfbb1a57d792513f19c28e989aed3e17", + 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: "def986371d12dab1abd72cf648c74e5bb9e543005a629289d69282c188353e94", + 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: "77abee8f88c8661a041465269b184208ab433a283a5c22c1abd3396138f90180", + 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__static_analysis_tests__static_check_error_bad_function_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_function_name.snap new file mode 100644 index 00000000000..e0342bdf0d6 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_function_name.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "958e85fdbd6d7dee181af20aa952a51577ebbf3bba213cfd6c19e98817192959", + 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: "25bedf706335e24c42cf710d27337a19863fb7aac1d2fd0048887173f02643b1", + 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: "52dd982457d65c8ba04a17e0f6f04b60bf2aaa0b575366704f15774f476856c7", + 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: "526adbd4cb28ab037c2bca72d6bab0bfec3062a9690290c83badcab759d6d2a1", + 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__static_analysis_tests__static_check_error_bad_let_syntax.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_let_syntax.snap new file mode 100644 index 00000000000..cf9e595d343 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_let_syntax.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "9a7b61f181ef8592a441f9ecc91bbc12f9a1793cfbec3513e4721f18d67d759c", + 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: "bd7f849c2ca3f82215077ff231c5b9ab2aabab13ffe6dde893ac874934486e89", + 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: "b9892b671586d1a137bce485d61a9413be9835ac270bc2b9d8e012d14148cda6", + 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: "88bca3a73fff95a22e4108e03d3e75b391b62baca8ea07fbed2f76889b099110", + 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__static_analysis_tests__static_check_error_bad_map_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_map_name.snap new file mode 100644 index 00000000000..f85b950249d --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_map_name.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "3986d2b49c834d730e91c37a0749894acbf15729a49fa0212b9972a2c44bbea2", + 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: "f73ce2a128df823fceb534d19390397feca6196c922a95f3fa8fcc5ddeb31be0", + 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: "c7cd24d368c0f4ddb7d3a8b86063dc3934decdb2e264714fbc9ad3a898fc48b3", + 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: "2a8f6c0917fbed26587e59b30895894d390e8d506e08e443b67fe97d306879a7", + 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__static_analysis_tests__static_check_error_bad_syntax_binding.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_syntax_binding.snap new file mode 100644 index 00000000000..3dfeb8dfaf3 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_syntax_binding.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5757a72059ef9758e18238aad508b3c505548d4ec91c188b0331abbf516231e2", + 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: "23abed8e414c422c7eaaf6981863e16f9e36f83e6588787e3b366d45a476d380", + 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: "32a47e26e9953fa3451bfcdf8ba00395b5d574b6e6472f8458774c3b29959ab4", + 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: "1cf5ce609cb847dd7558af25d631a1a12549c1ac377527d15fcb2a9db607aa0d", + 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__static_analysis_tests__static_check_error_bad_token_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_token_name.snap new file mode 100644 index 00000000000..c7786bc4873 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_token_name.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "3390089ac0826e8e5677d5093fa3d0db6081e88e6a1763017efc763d3cb96b16", + 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: "e5cab45ec9a8034bc8deefb862099bc775bad5bfca6bbe8896c5d4b69bd58773", + 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: "dd195890bfe644b746de8f2d27e986a2cc8407929d3e7ca32ce18f1460a40348", + 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: "bcc6deb5971a412ffbbf92f64405124ca3e0e0c1408e1da9d3da08d239e003a6", + 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__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 new file mode 100644 index 00000000000..5cc9021b887 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_trait_implementation.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "12d33d45dd2d1e1b69dc051295249fbea64a8c3fd09448e3997f6d9441724448", + 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: 3157, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3157, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "8ccaf85453bc27e815e4b127745b61c0e3ab40bf22e73fc7b8c74f5ac8c458f3", + 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: 3157, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3157, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "111496a7fc28efe5966db421eb0ecd0b736d5435ff490585ba801f1f5093b339", + 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: 3157, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3157, + ), + )), + Success(ExpectedBlockOutput( + marf_hash: "f4274bba15e471d656212d8e0b57f2386074437a263e743a0423715ea32d3f40", + 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: 3157, + ), + ), + ], + total_block_cost: ExecutionCost( + write_length: 17, + write_count: 1, + read_length: 1, + read_count: 1, + runtime: 3157, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_tuple_construction.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_tuple_construction.snap new file mode 100644 index 00000000000..e0f91a2dece --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_tuple_construction.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "c7325ae92d1ef974494c13e18014778fbe87f74a3c654eb5f9461aa7d38fcc34", + 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: "64981f31580117d55d9f3527ee4300d55d1eccb084965bcfa5ce6d86827635cf", + 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: "875b8f5f914d202184bd3bb618319af5d88c1692b902e069561e75a1b0da05d4", + 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: "779ea49997c7f6b76972ba2c855d0adf03dbb91ee5b60923421d72142e81a70f", + 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__static_analysis_tests__static_check_error_bad_tuple_field_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_tuple_field_name.snap new file mode 100644 index 00000000000..0c6cf9a1435 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_bad_tuple_field_name.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "c7325ae92d1ef974494c13e18014778fbe87f74a3c654eb5f9461aa7d38fcc34", + 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: "53e6f527920fae9c68d283cddb6bb234d6707f978ce1b7ea60e284c4c9da3782", + 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: "500aa6950d9812bd87c6085ad1d3108c926e1878ef1ba6fd223f490f67e04a45", + 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: "37d05369bb78bfa6f01ad670df20f3682e215a7f2e0e405e9c0b533e37e38b2d", + 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__static_analysis_tests__static_check_error_contract_call_expect_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_contract_call_expect_name.snap new file mode 100644 index 00000000000..5834dd54aa8 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_contract_call_expect_name.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "0baa8536816ea19016addf5641e710546c1337086d00ae90446b95d3cc4fab61", + 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: "2ed7c0c0aabed9df7b3fb279db73498156a063af779e047537f15f7d1a4fca97", + 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: "8f4226f89fa28f6cac5946c87e70301055d7bd8daf6e32545b99b6437a377940", + 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: "e294d7a75b14cf11124d8f842923b3e332b40c3fead74a57e2a224853c7d013b", + 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__static_analysis_tests__static_check_error_contract_of_expects_trait.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_contract_of_expects_trait.snap new file mode 100644 index 00000000000..60f09897f85 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_contract_of_expects_trait.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "68e84be6abc605f8b749ffddc651ac1638855423b92fafc696e2838da89dcf88", + 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: "1686e569006424107fbe3d0443019c8769d8bbb0773f38e17a1a226671304336", + 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: "1b37ce2a9bde28884ec5b15ba72017631a200bc33c6eda4b5deff0a71ff817b4", + 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: "31b6628796a3326feb9b789bb1850cab55ede05ca7d1cbf77e5ee1cabc775afd", + 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__static_analysis_tests__static_check_error_could_not_determine_serialization_type.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_could_not_determine_serialization_type.snap index 83c2fecb9fb..c750aef4acb 100644 --- a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_could_not_determine_serialization_type.snap +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_could_not_determine_serialization_type.snap @@ -6,36 +6,6 @@ expression: result Success(ExpectedBlockOutput( marf_hash: "b3b9782ccbe1bf3a66f1c34fe50c83c418fd9d6265761b0a82ffe9950dc8e30f", 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: "32e8a7c15c537c7cbffb74e28705816f8c607bd37d5b2fe9db78f24c697d506f", - evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( tx: "SmartContract(name: serialization-type-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", @@ -64,7 +34,7 @@ expression: result ), )), Success(ExpectedBlockOutput( - marf_hash: "a9b3550d29aff9a7a271ee1cb981e4bb3e1948d49026511cc8183fbe2aaeb8af", + marf_hash: "000052458b68bb6d4184aee0daf39736b0799c96514237aa8377e7c10f00fd61", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -94,7 +64,7 @@ expression: result ), )), Success(ExpectedBlockOutput( - marf_hash: "a390adec582f30b5d9b8cb0dec54acb082db7823cd7d55a11992fda3f5f96479", + marf_hash: "322b1c89f517b9a55c2487d6f900057dadab0c93034bd5120be87fd7dc7fe86f", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_default_types_must_match.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_default_types_must_match.snap new file mode 100644 index 00000000000..c7807a20c5b --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_default_types_must_match.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "30261957397a00a1facce85f43fffe82dbd7cd0d962c822b904bec0ba1c73af3", + 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: "3fab0f7cac72ffbd9fc0411401bdd99354e87f293ccfcfbe09bfbc9f2d8595a5", + 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: "bdc2a354a99671fecc71486e56ce504660026e6c0b978621499dde9853d21b6b", + 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: "7afcd0b4ec3fe54ff6b1f8d32e9c474a8221b0f26b0d9ffb166e9cfeec30c566", + 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__static_analysis_tests__static_check_error_define_function_bad_signature.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_define_function_bad_signature.snap new file mode 100644 index 00000000000..086229e8286 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_define_function_bad_signature.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "0d3b93bec153507aa367e009aaf31d22810569f48e6710442e930725c81135ab", + 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: "76b2af45f6a0ef7f8700b0733fb4a1bfaae4237d3c7e2dec921eaab45cf118e0", + 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: "fb0ff80618f517a6af2b659b1d71197d3fdeced528462234d5ac23815757173e", + 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: "79a0353d25a40feeb4524c567a7593a9e69ef0fb6b676350a7ecc43e0058d357", + 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__static_analysis_tests__static_check_error_define_nft_bad_signature.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_define_nft_bad_signature.snap new file mode 100644 index 00000000000..12e3d493c6d --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_define_nft_bad_signature.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "9bd61674813ec48aadc6a7e6d0e019dda68271947d89e128ef15fcf0734bc3de", + 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: "669e41818c99b7f54bf3acc1458387cd2c18ca67ab8830bd32e369f0c08b46ba", + 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: "cf975aa3e10d06b9d5870c7fb31b38986d2b4ee0924e03dc0667911cf0e321c5", + 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: "232e11cd51e7cbc9cb6e2990de3a6e4fb8851413ca076c8e7dbf7d08555c4833", + 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__static_analysis_tests__static_check_error_define_trait_bad_signature.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_define_trait_bad_signature.snap new file mode 100644 index 00000000000..365d51c314b --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_define_trait_bad_signature.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "f80d8825cf580fda2e36a975d7c02e0c227051a0f56ae0ee50ede8ea2e4266fb", + 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: "13cfd665a9fdb72caef26e86e8eb3697aa282c89e6aba8a08230aa50d7225dcb", + 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: "c4f2a04a75fcf53d1e4d31f6d308b026e00eb60f56e3f621536ce9e6754b2c2b", + 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: "345cd8885c37d1ac1c4e261aab67cd0e620d5edc5c13cdaa59948a9d9f21fa07", + 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__static_analysis_tests__static_check_error_define_trait_duplicate_method.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_define_trait_duplicate_method.snap new file mode 100644 index 00000000000..68bf0413e2f --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_define_trait_duplicate_method.snap @@ -0,0 +1,124 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "4761d32153c2f749dafe09d791baf35aa8a046e7f4fde6f5c8b93fa9b7bcacbd", + 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: "e3c3390d4abad1cc25ce01266beebbfb214946828db69f382c3f5f1c56c98639", + 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: "01be73c925b1fd4ccbf23afadc1f984e99456decca9bf9bfc71d48a31baa1d13", + 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: "90aa3aeb5edbb8c0b471ea204f3362f17bc9efd01e5ca64fe836a23195884460", + 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__static_analysis_tests__static_check_error_empty_tuples_not_allowed.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_empty_tuples_not_allowed.snap new file mode 100644 index 00000000000..70c70ecef50 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_empty_tuples_not_allowed.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "58c6ab144b728c66eb5768365171caaa535625fadd0477f89b31ecc06fed6ae9", + 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: "5fc51649f3bf6815a962093b6c0024627ae386e05c83d62a5a1fe2cf0c99266a", + 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: "7c9f9c8d866d06c45e607e23e3c5edc8ff4714cedbd8f2bdc46a710eb759e8fa", + 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: "b22382a280a12aba907a538d1c867f13662ad687e9659b0c94f6046c26ce4bea", + 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__static_analysis_tests__static_check_error_expected_allowance_expr.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_allowance_expr.snap new file mode 100644 index 00000000000..2e268763a39 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_allowance_expr.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "9bd61674813ec48aadc6a7e6d0e019dda68271947d89e128ef15fcf0734bc3de", + 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: "ead56ec3e06e418414e819e9a55bd17affa6e131a0d4677843a79cc341b62388", + 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: "a1f6132d9cfea7b9164264c51757705c0824058c71fe160b0cffea7dce88d55f", + 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: "21b046b1b87b9b7286ff90e8b581d11332217aafeb6c6b4210a7b0233d96a1ed", + 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__static_analysis_tests__static_check_error_expected_callable_type.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_callable_type.snap new file mode 100644 index 00000000000..4f3d8029f02 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_callable_type.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "7a4f5f0d2ec2d0f9cdd0d5823011db3ee594b1c8584d7facba738f6d0259745d", + 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: "f34f8bd525a5db96c93c2c458ca3f8ca1d62be92814f430fbe505be3c1adbd39", + 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: "eb20bf676d349a7ac6edb5f4cc3a2a06d30a94a6b80d5de35d38217bbee12b9c", + 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: "8aeacc70587557483585a8402785eb6451749dfde26d725b16dd455016050e6d", + 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__static_analysis_tests__static_check_error_expected_list_application.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_list_application.snap new file mode 100644 index 00000000000..c508c19b98e --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_list_application.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "26a7cf9478898f9b24f8aca56188ac912a1e505770bf0c0f15f8a1deeab06c54", + 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: "49c6a767e73a9f036b33fe9846f9c4165f935f3ff66a363488909366eb95bc55", + 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: "c3a681a97a0bb1d153d09e92133d4a65d9f2815f447d0a2a13f5a61538d34024", + 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: "93519863161a77d5ec36ea36e644215fee98a27813f181c8834b8cf0abd16b97", + 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__static_analysis_tests__static_check_error_expected_list_of_allowances.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_list_of_allowances.snap new file mode 100644 index 00000000000..ce2cdc90b7b --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_list_of_allowances.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "080e462a7a4181ec7a8eeecef8d0902641c1d9e71e8c70416c7dd1816231d41f", + 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: "846f8f5ea7019adc3ab01d96efa17c4e8d6d552cdb159acb8691bdc5d170fb6a", + 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: "307c1e7335c7c95ac250b88b5a51d625e0e3127f7287c0c5c2edd750ed830496", + 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: "0e9b29d8c3f64a7e6e4e5f1137ed3229ec80059abc854d957703f9bd5589dc55", + 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__static_analysis_tests__static_check_error_expected_optional_or_response_type.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_optional_or_response_type.snap new file mode 100644 index 00000000000..07d3160d3e1 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_optional_or_response_type.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "3de467f48119164c4e38dd507c6ac2dd63d252126c28fc55a565e24811e350fa", + 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: "d48d16f993514ee365ad3a5084e5a0cd90ffaa998576f29b08ea7829061d8fdb", + 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: "2a70d824d647785c1a02731ef4f0c171418a95141a713fd30bf242a2b924d871", + 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: "bc318401894ea3764f45c3953e42c42459616b9fdff0f66f6e8ac78cf466a052", + 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__static_analysis_tests__static_check_error_expected_tuple.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_tuple.snap new file mode 100644 index 00000000000..cff0f070627 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_expected_tuple.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "a1ba1c6711af9225754f4503aaa15ea11c8b043513b5630c32582be50ebf43a3", + 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: "b1cbab15093f365816c5ff07d570d4d2cab5d461797cef48082a05a108cd64b5", + 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: "5703a29c37bb7dd3ff5eacb94ead510ef26e9a3318e2c35cd501549c61054167", + 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: "f65260e67901ed7e31cf93b18a6633c4dca0ce207817b302265257fe4c4e6726", + 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__static_analysis_tests__static_check_error_get_block_info_expect_property_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_get_block_info_expect_property_name.snap new file mode 100644 index 00000000000..421450943a1 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_get_block_info_expect_property_name.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "cb5ff6bc3fe2978e0d48ad53032bd7b51715fcfa099febbbbc11effc17f2f919", + 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: "e0b3b7122d17266152730aeae6ca52fd269e37d495a4aa5a9ef6e5cca13d546a", + 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: "824a0e4cb478e765acebcd22393613d168f8de0159ec08d01a4b20613b295272", + 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: "3b5cccef5110159bb36f461e9ce585ca94887367314661a4415bea1b27a73d5b", + 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__static_analysis_tests__static_check_error_get_burn_block_info_expect_property_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_get_burn_block_info_expect_property_name.snap new file mode 100644 index 00000000000..d1c681e59d0 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_get_burn_block_info_expect_property_name.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5311183dc3e03047bd9570c885a42a7d3f6a132564c698d1c01754a21277375e", + 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: "14a30a665f9f6204455aa41d21dc7ff9b3d710c29d3ee490cf9631bb2fb63e3d", + 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: "4714ece198f90f4cd565fb293867e8f05df0cabeba9b586903b030e42dc841c7", + 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: "8df3c9c624da5ec3e0ea74a46bdbccbefee01853b455e2369510fb4907ef57b3", + 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__static_analysis_tests__static_check_error_get_stacks_block_info_expect_property_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_get_stacks_block_info_expect_property_name.snap new file mode 100644 index 00000000000..72d3b980437 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_get_stacks_block_info_expect_property_name.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5e4bbfaf3781fa1f6772bafc466a0e54ead257511f09e1d83bd8e461a4ef60d4", + 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: "ab165269944ca8edf77e988bbb07d3faee1fd7c48261306c60766dd1cd02baf8", + 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: "b84bc477b56ed60e61a9d58b20c0ddb8f4d2023737234d788f4fb864e763f28e", + 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: "dcf637de7a31cd602d370436f00deddc462d4fc7225f19173851d69aff1fd0bb", + 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__static_analysis_tests__static_check_error_get_tenure_info_expect_property_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_get_tenure_info_expect_property_name.snap new file mode 100644 index 00000000000..8e517f7ce62 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_get_tenure_info_expect_property_name.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "958e85fdbd6d7dee181af20aa952a51577ebbf3bba213cfd6c19e98817192959", + 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: "5ee21dfa79d3d24eea53c7c07fd7be6e86b9f3e554432a31bb8a23499b48d901", + 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: "cd8874115c640eb3d46ed20326cd28e62ef6d462324a4ebb0f6e577cf3c3c116", + 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: "5c85fb385f2672808940d4a30ac5c4022121379322551b5a686c258cf3698bc9", + 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__static_analysis_tests__static_check_error_if_arms_must_match.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_if_arms_must_match.snap new file mode 100644 index 00000000000..16b8efb718c --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_if_arms_must_match.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "68e84be6abc605f8b749ffddc651ac1638855423b92fafc696e2838da89dcf88", + 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: "17d67b2dc90b68061c646dd066a4715e2f94f5f680462d91b38fc0ce1c62aff5", + 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: "1bfef61e9b94cf689c03cea835d26f747d6bb009923a1d6648747f69bc24fb5a", + 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: "974ef8d241da5da9690a045ee8c8584f1977711c3f6a9b28ac27e2f0304fc451", + 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__static_analysis_tests__static_check_error_illegal_or_unknown_function_application.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_illegal_or_unknown_function_application.snap new file mode 100644 index 00000000000..eb1245f62e6 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_illegal_or_unknown_function_application.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "c7325ae92d1ef974494c13e18014778fbe87f74a3c654eb5f9461aa7d38fcc34", + 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: "8c5aa701c6f5bfdea3b0c4df1753c523064047ecac9157372925417c98614c36", + 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: "01ea0cb64763fa6d72f3dfb6a11ee8b41e7f75d7fdd9cdbc0c3cc18eabdd6020", + 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: "2bf1a90fe696763b4bbd9cc1009a67b9bc52eb61c7dd4bc5320df60dad3ce356", + 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__static_analysis_tests__static_check_error_incompatible_trait.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_incompatible_trait.snap new file mode 100644 index 00000000000..d85e3a9be72 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_incompatible_trait.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "1a93804dc742a3f03d31684ac4548229f31c5d375a3426fd96cdcebd7d645e91", + 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: "077f2e58b7d899f0ae06b675f3cae7209e0d7c67144d2220aec1e30d1a5590f4", + 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: "6e0c426707d05d4b770e487d836b9f56da67239a9693db77d7f1c5605e9a3ead", + 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: "ccc4a7402c9aa8f7db5ad4a8719465e83eb21c7e33faecee0f25c30ac2966cce", + 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__static_analysis_tests__static_check_error_incorrect_argument_count.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_incorrect_argument_count.snap new file mode 100644 index 00000000000..bd09ed7fdaa --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_incorrect_argument_count.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "cb5ff6bc3fe2978e0d48ad53032bd7b51715fcfa099febbbbc11effc17f2f919", + 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: "5228eb6774874cafae8a3ebdaf0b479cf2ed71a4cfd93a474aba042d7e205dc0", + 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: "6ee5821301445e04cb2ffa00ffb78a8b972a0cbf466e6cb64656229f9ea731cb", + 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: "e4bda05caa58cbc187f11e14b57be40a4127a400c993d6b66145568d87d4469c", + 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__static_analysis_tests__static_check_error_max_identifier_length_exceeded.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_max_identifier_length_exceeded.snap new file mode 100644 index 00000000000..d8c95649ac2 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_max_identifier_length_exceeded.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "9dd6b272e6b172c3dc38c13567f38974e96caef45e70e4c1b362acaad56c838f", + 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: "3c231659b4489fa1539b0df33f777c06b9bc3023c30699a4f8fb9fa36e052345", + 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: "e02ec61d4a08e492209cef98208aad69e9fbaf5127d3e7720c5e41aa66e0d034", + 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: "eb4695d92c47020370d0cbe58734c8facf6f47a75afa1810b27a6ef1b3bd5bc2", + 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__static_analysis_tests__static_check_error_no_such_block_info_property.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_block_info_property.snap new file mode 100644 index 00000000000..6c4f64c3216 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_block_info_property.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5e4bbfaf3781fa1f6772bafc466a0e54ead257511f09e1d83bd8e461a4ef60d4", + 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: "92416f81d8f176f3502973d49ae12b8f5bcb775d60540eb2712984fdd31f48d5", + 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: "ecd44b2c8364f595a463ee3343a9200f074b53865f9384b2f950411b5ef130cf", + 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: "c02b6614c84aaa45bf63ecedbd58bb702bd512c840ddbfc1e259f1110cf9ef01", + 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__static_analysis_tests__static_check_error_no_such_contract.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_contract.snap new file mode 100644 index 00000000000..7095eed2ff3 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_contract.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "cb65c4db199772d38250885573213cd047ab5a6005280da51ec86ec999d84665", + 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: "f7316094315e5d5ac178cc4fbf95341c5881e8c61edb52f645dbf7cdd67feb18", + 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: "fd98f918d2b6d52ef0aea257587312a017f213dce48a4bf091571535020c5004", + 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: "3bde921adb5ec8f2bc5923735cfbba7a51199a2326bd36274088d7e3c85a61e8", + 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__static_analysis_tests__static_check_error_no_such_data_variable.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_data_variable.snap new file mode 100644 index 00000000000..1f7090f53f4 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_data_variable.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "50a7d2b847f18b54c70237597e75621b9c0ef23979ecc6ed160fea98f0fa2402", + 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: "b5b550f8391d122c71f2d575cea5ce019d2f5ac70ddc21febfe12b27ef543f57", + 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: "8d390aa9383d4f3a44fca23cd2500800772be498ac2ccf597babdaed82956b91", + 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: "281ef21d7a2a70e2fc18001a1549425af557b53b72c98ebaac4393e8a77704e6", + 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__static_analysis_tests__static_check_error_no_such_ft.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_ft.snap new file mode 100644 index 00000000000..66a74dafeb5 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_ft.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: 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: "2a8ef23dd15fa90350e9435cc60f2eb1b638cc22e6465301ae951fae64fad714", + 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: "55d35c7909bcbb26fef287cdb3a6a370d6d835d898dbffd3161145cff2cfb0a3", + 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: "68dfd25e2274ddc5a37d8df70aff670b46cf18c51870521cacc1375b9f904ea0", + 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__static_analysis_tests__static_check_error_no_such_map.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_map.snap new file mode 100644 index 00000000000..7c4f1899730 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_map.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "e98fcb2f30a5cca370fc492fca335c2094657af7c8229458cf187a26f82b8bbf", + 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: "2e60017ad42ef0c335699107b71612755451d95258bc0b07c9cf6ac6663cf3b9", + 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: "3c2493928bbe73bf44a80cd72a68e265381c5cb777b6ac6dcc0f686d9dfffb5c", + 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: "f90b3a977860c34f8ba95f7f5187bc447fe8ed4416b5ae354590c9f66b1b16a6", + 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__static_analysis_tests__static_check_error_no_such_nft.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_nft.snap new file mode 100644 index 00000000000..537d945bd89 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_nft.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "56fa04cf02387fdc8e68b68ad163927126a2928ac81eb1bb1605a3399017304d", + 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: "86b2d758ddee687dc42948d4dfd0ed94a5c109831e5383b28708f3c196b2f4b0", + 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: "fc7ff58c3d0860ee7a0b3e223c5e39924eb53180f8be38ee64f733dc1648d256", + 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: "56c0870f17b38ae5fc0c0c1c6f4fa8176bf487be70f393ceb92199e9ee898b2e", + 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__static_analysis_tests__static_check_error_no_such_public_function.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_public_function.snap new file mode 100644 index 00000000000..d0c4a8eae2b --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_public_function.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "ef8ca5e533b17f2746804c4ead9de18b1a04cb18dabe4c1c8d309a19628912e4", + 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: "1478b5991938a292f48ad6c99d4c73c249fcb6d204bd8767f24ec6552706d872", + 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: "8b43ac26e0f5478ea5eee07b9ba210b5612a44b9790bc78e41c04d218df02e09", + 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: "fc35fc956ded04bc69eeed04007653a9f1bad12a06a9a86c5149e7454639e8a8", + 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__static_analysis_tests__static_check_error_no_such_stacks_block_info_property.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_stacks_block_info_property.snap new file mode 100644 index 00000000000..7a06cbb4c4c --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_stacks_block_info_property.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "3390089ac0826e8e5677d5093fa3d0db6081e88e6a1763017efc763d3cb96b16", + 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: "64fb9f9ab0c3614ea4e930ebfe84e18fadc7416c45239de31a6e4b855230980b", + 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: "cfc29fea26824fd483854c762b704c0822c18f5effa466ad963b680e016f6c6d", + 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: "cc72f611641398e40a9d3008a4fb4c94071d0f7ba1d61ac620cb3c23823ac4dc", + 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__static_analysis_tests__static_check_error_no_such_tenure_info_property.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_tenure_info_property.snap new file mode 100644 index 00000000000..107065a6c4a --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_tenure_info_property.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "690118c9fd710a6064dffcf0e76029e0cddb898e18675d08e48a62c6e0ea4828", + 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: "f4f43aafbfcc0676d2ad3ed87d90c473cac22556ccac3246c8dd37b400d9cda7", + 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: "be199009a8b762ae60977346071454847224f1db84606165ffaec578dc89f5a6", + 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: "b5de5c80c5a5a1c7a89085975004564d49140632b3177e512df6a64b1801a61e", + 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__static_analysis_tests__static_check_error_no_such_tuple_field.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_tuple_field.snap new file mode 100644 index 00000000000..1bb07fdfe81 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_no_such_tuple_field.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "5311183dc3e03047bd9570c885a42a7d3f6a132564c698d1c01754a21277375e", + 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: "aafac2400c9f46aa4757effb68e47f1bbbc3656762aa7f559314f5c315955a21", + 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: "9448f4697bfcc8f0017d7624be86e4066e1611f00ba2e377a76986057862af2d", + 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: "330e9e70da320f3623685c31803bb3058985178b1e2e10873e9a1dd6863c3731", + 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, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_non_function_application.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_non_function_application.snap new file mode 100644 index 00000000000..da45c82d904 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_non_function_application.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "a1ba1c6711af9225754f4503aaa15ea11c8b043513b5630c32582be50ebf43a3", + 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: "5e191be88410092614da6257b0ba35c94719661e187b6b4be0afa3ed6a56e729", + 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: "52f92f4990c2752eb3131f983126a2697b432f47c51876376b92c7e996c10d3b", + 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: "ea5433d4326b513d4b121aa290241c3bc36f3aa889e6f872244a118b49b29bfd", + 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__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/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_reserved_word.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_reserved_word.snap new file mode 100644 index 00000000000..3fdb7035fde --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_reserved_word.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "080e462a7a4181ec7a8eeecef8d0902641c1d9e71e8c70416c7dd1816231d41f", + 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: "4f892af1a8a0482ac3b3484326827e306ec68c081aac438cf73738703bc2b470", + 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: "bf4452408f9e33d9a4230c4542ca06ee24dae1be2cb09160e2e5b6e4dfa9fd35", + 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: "5bac3e80337a660b56e8f46d47ad93ee63f12fafb48d1feac32a2a7a44f0a20f", + 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__static_analysis_tests__static_check_error_too_many_allowances.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_too_many_allowances.snap new file mode 100644 index 00000000000..bd18c31588c --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_too_many_allowances.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "0ae4e1e13b67a919db60017efe073dafc1785c8a4065908d316580bd5a893c5d", + 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: "a049ace42711595f51b9baa3018cf4b80c72154a10cce9c2a684a1801febdb23", + 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: "69319b26d229a11bd303a23a6e4d2ec43c7f3585d4766f332577e72d1bd044ac", + 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: "051919f48420c27a72a19a7596444ea051d6716c42b3971c8afcdc4b0448f429", + 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__static_analysis_tests__static_check_error_too_many_function_parameters.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_too_many_function_parameters.snap new file mode 100644 index 00000000000..6a00a27d377 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_too_many_function_parameters.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "51a9d4d6a816bdd1e92d4cfac521a418d8cee787792789298efb632d1bcb8bab", + 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: "628c64177ed5b43871fcc2bd01aca435323ff71dc797c2c3f30e9d148754e992", + 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: "a5083ad371b92eee22aac7076556ec90fc3595f7356fd874a8468427d3849771", + 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: "ee51cf5ddbbc54498c2888dee162d23164f6e486cfef544fe5bed887e079b3b4", + 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__static_analysis_tests__static_check_error_trait_method_unknown.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_trait_method_unknown.snap new file mode 100644 index 00000000000..38ac475ae9e --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_trait_method_unknown.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "a925c201881f9c7149edb74985364d4e86a42cb0894811728f3e71c68ef53607", + 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: "35b7334ac59f88a13a95025c2628ac7b747fa0f641788cb9e6e3b043c95ed6dd", + 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: "87b22a54be9809e39fe3bf61d8d0a9161ff0247408273039d114804433102dd1", + 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: "c5f2037cec2f8e26848997e2bd60fc5a1808e22d064426f8c7dfe6ccb334840f", + 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__static_analysis_tests__static_check_error_trait_reference_unknown.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_trait_reference_unknown.snap new file mode 100644 index 00000000000..0130cfa10ce --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_trait_reference_unknown.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "d0a94b5b4ced232c0486676e46e31c76bceec5392bb7f6ffd31577e50ff99ca0", + 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: "1b4f335ad5764e2fa177afbbd2a7b9883efe30d262b28626d0eef692c8f1c327", + 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: "14d91c5f8a01918944f4895723b4e73b6c2fea0fa414c54df4bf497169600c44", + 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: "2a7a1dca4d1856d94ceb3237d69a9beb7ee19e0c4e370f95e3d61e7052fd79c1", + 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__static_analysis_tests__static_check_error_trait_too_many_methods.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_trait_too_many_methods.snap new file mode 100644 index 00000000000..5147ab5e7e3 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_trait_too_many_methods.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "7b3b22d0107e05d40a066b9235572a3a3158d4075985c61b0c857c0dddbdbc0a", + 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: "3518af9fede23f6500dfe0a7dff52e8056413146d8f8227c974d011867b766ce", + 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: "cb06c378924b9b5f23feff54ce6adb506a90cfa851ba50cd7293df08e27058d3", + 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: "18396ce9aa4c072b9b9e1b254b520032904d7f25e3c61eb129ea7602ec75bb73", + 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, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_unchecked_intermediary_responses.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_unchecked_intermediary_responses.snap new file mode 100644 index 00000000000..225c1d5e122 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_unchecked_intermediary_responses.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "44404afb73f927ad02e570b5189847084801458e4a8b68eb1a92273c0e13794d", + 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: "53ee0e161ae3c99502b61b1cbc75b70a26a85fc67cb805285de2deedd4a0632b", + 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: "60a072c35aa07afd9656cd0d3413cf1e16996dd2dea5fd36fb6ea92aee76772e", + 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: "264a55159341b88b30fa5c70c3cc965bc92e237fdefbadd1a788a7d51ca49787", + 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__static_analysis_tests__static_check_error_unexpected_trait_or_field_reference.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_unexpected_trait_or_field_reference.snap new file mode 100644 index 00000000000..ea0bae8c33c --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_unexpected_trait_or_field_reference.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "4df8213bfda7f9306cb9a8cc6cb151da417f319be324e03a26594a437e72c474", + 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: "0ae3236c8b5bb036b14deb4fd47186102c90b359f7f6419462f50c6705affbb9", + 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: "5b1515a1e15a95b5fa85697ea620d0b86c57a5b22096b32d4097fc2b8e0067dc", + 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: "45ecdc8f37187d87929c7853346cdb33e7c906892e1a90670ac02dd7c169f7d0", + 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__static_analysis_tests__static_check_error_unknown_function.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_unknown_function.snap new file mode 100644 index 00000000000..41e1ce2f160 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_unknown_function.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "1ee5bdee72193aa745d290a84719f9e59f3e339572c34d4f2c495243960a3a64", + 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: "183103b236d5fd0239800d3796872caf19f3fac3ee53d700b25cb9474bb2a2a7", + 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: "4f78241cf302593d752758fbd1d3c7c0430d6cc8404d77f8819a113c3be0acd0", + 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: "78ee0a2b71d680c7a5a5a9538c730648c9b2a25c17c158f07e27684fa8325325", + 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, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_unknown_type_name.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_unknown_type_name.snap index 1b07f47cf1f..37bb457dd8c 100644 --- a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_unknown_type_name.snap +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_unknown_type_name.snap @@ -6,36 +6,6 @@ expression: result Success(ExpectedBlockOutput( marf_hash: "8d004a3557c0396f4fc38d9ce6bf700be2d07f6afab03f03ff4e97ab98fe0f01", 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: "eb4d4eb367b43b2b4bc7d93341c6bca0a24204c2a0a30706a8a18b5dcaf146e3", - evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( tx: "SmartContract(name: unknown-type-name-Epoch3_3-Clarity2, code_body: [..], clarity_version: Some(Clarity2))", @@ -64,7 +34,7 @@ expression: result ), )), Success(ExpectedBlockOutput( - marf_hash: "e34776337382364c9cad419d37cd265c7c9c62c36e404641a942ee13f6566562", + marf_hash: "cbe12e1fc1ac7d7c8e51a5017f252d5194eae8f9954bda1db5ff63919ecaea6b", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( @@ -94,7 +64,7 @@ expression: result ), )), Success(ExpectedBlockOutput( - marf_hash: "33484e3c68f4d42586a392be72eaf557996936ebd7cd002151817474bd409aee", + marf_hash: "461b19fae1c2c4c055386fe3500aca96406c7b4438828249ec0a1d89939348a5", evaluated_epoch: Epoch33, transactions: [ ExpectedTransactionOutput( diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_with_all_allowance_not_allowed.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_with_all_allowance_not_allowed.snap new file mode 100644 index 00000000000..9aafd03757c --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_with_all_allowance_not_allowed.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "592f6545c67772255bea2a807b441ff6f4535efa2ea58964358b15023b2215f1", + 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: "6e779fb60befde7d275fc884c278de979e6d5fe80a8f5923382673779e0f5842", + 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: "eb88b0f4a9c57ec55a2659839e1c29686b7cda9e3650c42b219eb18ae9821097", + 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: "9b658213cc2c6b61d4f193922330e2e36c8eed145af7be40b8f1b274c43f5d3e", + 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__static_analysis_tests__static_check_error_with_all_allowance_not_alone.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_with_all_allowance_not_alone.snap new file mode 100644 index 00000000000..9e40d67400b --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_with_all_allowance_not_alone.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "4df8213bfda7f9306cb9a8cc6cb151da417f319be324e03a26594a437e72c474", + 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: "b40f557a48e7ec3817ed5d3f9d999e0997eb70f0eaef6dd7adae78f8c6d68d01", + 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: "92e267894e85d0975c34e77c0c94f632eca4491d501cb78c2017aca2e8c6d3c0", + 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: "89d9563a3190b937163400693017c1f887a7a74435c99519a33a5d8b99ae9076", + 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__static_analysis_tests__static_check_error_with_nft_expected_list_of_identifiers.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_with_nft_expected_list_of_identifiers.snap new file mode 100644 index 00000000000..bb152784ad6 --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_with_nft_expected_list_of_identifiers.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "50a7d2b847f18b54c70237597e75621b9c0ef23979ecc6ed160fea98f0fa2402", + 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: "c5ffabb9dafcaab1b3fcfe0481693cc7b2e0ecab2062b4e0a865a8b5310ba5e5", + 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: "280d48f3d45d83c9fea340888c82fddc7207e7e609e5f668edd3c26eafbe12f6", + 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: "0cc3089252a382f7806fea8c39c773fe1adf7291cfbe21f86acb5703ccc1ac3e", + 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, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_write_attempted_in_read_only.snap b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_write_attempted_in_read_only.snap new file mode 100644 index 00000000000..8284f0a63bf --- /dev/null +++ b/stackslib/src/chainstate/tests/snapshots/blockstack_lib__chainstate__tests__static_analysis_tests__static_check_error_write_attempted_in_read_only.snap @@ -0,0 +1,126 @@ +--- +source: stackslib/src/chainstate/tests/static_analysis_tests.rs +expression: result +--- +[ + Success(ExpectedBlockOutput( + marf_hash: "46d7a492d7193b90da9df916ea21aac0b9f068e3aa32146adc1e78bffac73f48", + 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: "49444c1788d84f5f5716e71db049d942a430c4487c2aeada3b86dd24a00e6212", + 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: "f9233e0ec4e33c2db598427877a82173c43a10a73d5f01786869fd63fbd64a12", + 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: "cf65c9425dcbbacdc72b366f19ea51c508e779049a1d2425eaeb4909af848101", + 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, + ), + )), +] diff --git a/stackslib/src/chainstate/tests/static_analysis_tests.rs b/stackslib/src/chainstate/tests/static_analysis_tests.rs index f12c556d30a..0c5e6696750 100644 --- a/stackslib/src/chainstate/tests/static_analysis_tests.rs +++ b/stackslib/src/chainstate/tests/static_analysis_tests.rs @@ -13,17 +13,29 @@ // 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 analysis. +//! This module contains consensus tests related to Clarity StaticCheckErrorKind errors that happens during contract analysis. +use std::collections::HashMap; + +use clarity::codec::StacksMessageCodec as _; +use clarity::consts::CHAIN_ID_TESTNET; +use clarity::types::StacksEpochId; +use clarity::vm::analysis::type_checker::v2_1::{MAX_FUNCTION_PARAMETERS, MAX_TRAIT_METHODS}; #[allow(unused_imports)] -use clarity::vm::analysis::CheckErrorKind; +use clarity::vm::analysis::StaticCheckErrorKind; use clarity::vm::types::MAX_TYPE_DEPTH; +use clarity::vm::ClarityVersion; -use crate::chainstate::tests::consensus::contract_deploy_consensus_test; +use crate::chainstate::stacks::StacksTransaction; +use crate::chainstate::tests::consensus::{ + 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; use crate::util_lib::boot::boot_code_test_addr; -/// CheckErrorKind: [`CheckErrorKind::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 @@ -51,7 +63,7 @@ fn static_check_error_cost_balance_exceeded() { ); } -/// CheckErrorKind: [`CheckErrorKind::ValueTooLarge`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ValueTooLarge`] /// Caused by: Value exceeds the maximum allowed size for type-checking /// Outcome: block accepted. #[test] @@ -62,7 +74,7 @@ fn static_check_error_value_too_large() { ); } -/// CheckErrorKind: [`CheckErrorKind::ValueOutOfBounds`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ValueOutOfBounds`] /// Caused by: Value is outside the acceptable range for its type /// Outcome: block accepted. #[test] @@ -74,7 +86,7 @@ fn static_check_error_value_out_of_bounds() { ); } -/// CheckErrorKind: [`CheckErrorKind::ExpectedName`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedName`] /// Caused by: Expected a name (e.g., variable) but found an different expression. /// Outcome: block accepted. #[test] @@ -85,7 +97,7 @@ fn static_check_error_expected_name() { ); } -/// CheckErrorKind: [`CheckErrorKind::ExpectedResponseType`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedResponseType`] /// Caused by: Expected a response type but found a different type. /// Outcome: block accepted. #[test] @@ -96,7 +108,7 @@ fn static_check_error_expected_response_type() { ); } -/// CheckErrorKind: [`CheckErrorKind::CouldNotDetermineResponseOkType`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineResponseOkType`] /// Caused by: `unwrap!` on literal `(err 3)` leaves the response `ok` type unknown. /// Outcome: block accepted. #[test] @@ -107,7 +119,7 @@ fn static_check_error_could_not_determine_response_ok_type() { ); } -/// CheckErrorKind: [`CheckErrorKind::CouldNotDetermineResponseErrType`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineResponseErrType`] /// Caused by: `unwrap-err-panic` on `(ok 3)` gives no way to infer the response `err` type. /// Outcome: block accepted. #[test] @@ -118,7 +130,7 @@ fn static_check_error_could_not_determine_response_err_type() { ); } -/// CheckErrorKind: [`CheckErrorKind::CouldNotDetermineMatchTypes`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineMatchTypes`] /// Caused by: matching a bare `none` provides no option type, leaving branch types ambiguous. /// Outcome: block accepted. #[test] @@ -129,7 +141,7 @@ fn static_check_error_could_not_determine_match_types() { ); } -/// CheckErrorKind: [`CheckErrorKind::MatchArmsMustMatch`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::MatchArmsMustMatch`] /// Caused by: the `some` arm yields an int while the `none` arm yields a bool. /// Outcome: block accepted. #[test] @@ -140,8 +152,8 @@ fn static_check_error_match_arms_must_match() { ); } -/// CheckErrorKind: [`CheckErrorKind::BadMatchOptionSyntax`] -/// Caused by: option `match` expecting 4 arguments, got 3. +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMatchOptionSyntax`] +/// Caused by: option `match` expecting 4 arguments, got 3 /// Outcome: block accepted. #[test] fn static_check_error_bad_match_option_syntax() { @@ -151,7 +163,7 @@ fn static_check_error_bad_match_option_syntax() { ); } -/// CheckErrorKind: [`CheckErrorKind::BadMatchResponseSyntax`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMatchResponseSyntax`] /// Caused by: response `match` expecting 5 arguments, got 3. /// Outcome: block accepted. #[test] @@ -162,7 +174,7 @@ fn static_check_error_bad_match_response_syntax() { ); } -/// CheckErrorKind: [`CheckErrorKind::RequiresAtLeastArguments`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::RequiresAtLeastArguments`] /// Caused by: invoking `match` with no arguments. /// Outcome: block accepted. #[test] @@ -173,7 +185,7 @@ fn static_check_error_requires_at_least_arguments() { ); } -/// CheckErrorKind: [`CheckErrorKind::RequiresAtMostArguments`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::RequiresAtMostArguments`] /// Caused by: `principal-construct?` is called with too many arguments. /// Outcome: block accepted. #[test] @@ -184,7 +196,7 @@ fn static_check_error_requires_at_most_arguments() { ); } -/// CheckErrorKind: [`CheckErrorKind::BadMatchInput`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMatchInput`] /// Caused by: `match` input is the integer `1`, not an option or response. /// Outcome: block accepted. #[test] @@ -195,7 +207,7 @@ fn static_check_error_bad_match_input() { ); } -/// CheckErrorKind: [`CheckErrorKind::ExpectedOptionalType`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedOptionalType`] /// Caused by: `default-to` second argument `5` is not an optional value. /// Outcome: block accepted. #[test] @@ -206,7 +218,26 @@ fn static_check_error_expected_optional_type() { ); } -/// CheckErrorKind: [`CheckErrorKind::NameAlreadyUsed`] +/// 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( + "trait-contract", + "(define-trait trait-1 ((get-1 ((list 10 uint)) (response uint uint))))", + ); + + contract_deploy_consensus_test!( + contract_name: "contract-name", + contract_code: " + (impl-trait .trait-contract.trait-1) + (define-public (get-1 (x (list 5 uint))) (ok u1))", + setup_contracts: &[setup_contract], + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NameAlreadyUsed`] /// Caused by: redefining constant `foo` a second time. /// Outcome: block accepted. #[test] @@ -219,7 +250,7 @@ fn static_check_error_name_already_used() { ); } -/// CheckErrorKind: [`CheckErrorKind::ReturnTypesMustMatch`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ReturnTypesMustMatch`] /// Caused by: `unwrap!` default returns `err 1` while the function returns `err false`, so response types diverge. /// Outcome: block accepted. #[test] @@ -236,7 +267,7 @@ fn static_check_error_return_types_must_match() { ); } -/// CheckErrorKind: [`CheckErrorKind::TypeError`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::TypeError`] /// Caused by: initializing `define-data-var cursor int` with the boolean `true`. /// Outcome: block accepted. #[test] @@ -247,7 +278,7 @@ fn static_check_error_type_error() { ); } -/// CheckErrorKind: [`CheckErrorKind::DefineVariableBadSignature`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineVariableBadSignature`] /// Caused by: `define-data-var` is provided only a name and value, missing the required type. /// Outcome: block accepted. #[test] @@ -258,7 +289,7 @@ fn static_check_error_define_variable_bad_signature() { ); } -/// CheckErrorKind: [`CheckErrorKind::InvalidTypeDescription`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::InvalidTypeDescription`] /// Caused by: `define-data-var` uses `0x00` where a valid type description is required. /// Outcome: block accepted. #[test] @@ -269,7 +300,7 @@ fn static_check_error_invalid_type_description() { ); } -/// CheckErrorKind: [`CheckErrorKind::TypeSignatureTooDeep`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::TypeSignatureTooDeep`] /// Caused by: parameter type nests `optional` wrappers deeper than [`MAX_TYPE_DEPTH`]. /// Outcome: block accepted. #[test] @@ -292,7 +323,7 @@ fn static_check_error_type_signature_too_deep() { ); } -/// CheckErrorKind: [`CheckErrorKind::SupertypeTooLarge`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::SupertypeTooLarge`] /// Caused by: combining tuples with `buff 600000` and `buff 10` forces a supertype beyond the size limit. /// Outcome: block rejected. #[test] @@ -308,7 +339,7 @@ fn static_check_error_supertype_too_large() { ); } -/// CheckErrorKind: [`CheckErrorKind::ConstructedListTooLarge`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ConstructedListTooLarge`] /// Caused by: mapping `sha512` over a list capped at 65,535 elements constructs a list past [`MAX_VALUE_SIZE`]. /// Outcome: block accepted. #[test] @@ -325,7 +356,7 @@ fn static_check_error_constructed_list_too_large() { ); } -/// CheckErrorKind: [`CheckErrorKind::UnknownTypeName`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::UnknownTypeName`] /// Caused by: `from-consensus-buff?` references an undefined type named `foo`. /// Outcome: block accepted. /// Note: during analysis, this error can only be triggered by `from-consensus-buff?` @@ -338,10 +369,22 @@ fn static_check_error_unknown_type_name() { contract_code: " (define-public (trigger) (ok (from-consensus-buff? foo 0x00)))", + exclude_clarity_versions: &[ClarityVersion::Clarity1], + ); +} + +/// 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)", ); } -/// CheckErrorKind: [`CheckErrorKind::UnionTypeError`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::UnionTypeError`] /// Caused by: `map` applies subtraction to booleans. /// Outcome: block accepted. #[test] @@ -352,7 +395,7 @@ fn static_check_error_union_type_error() { ); } -/// CheckErrorKind: [`CheckErrorKind::UndefinedVariable`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::UndefinedVariable`] /// Caused by: `x`, `y`, and `z` are referenced without being defined. /// Outcome: block accepted. #[test] @@ -363,7 +406,7 @@ fn static_check_error_undefined_variable() { ); } -/// CheckErrorKind: [`CheckErrorKind::BadMapTypeDefinition`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadMapTypeDefinition`] /// Caused by: Invalid map type definition in a `(define-map ...)` expression. /// Outcome: block accepted. #[test] @@ -374,7 +417,7 @@ fn static_check_error_bad_map_type_definition() { ); } -/// CheckErrorKind: [`CheckErrorKind::CouldNotDetermineType`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineType`] /// Caused by: `(index-of (list) none)` supplies no concrete element types. /// Outcome: block accepted. #[test] @@ -385,7 +428,7 @@ fn static_check_error_could_not_determine_type() { ); } -/// CheckErrorKind: [`CheckErrorKind::ExpectedSequence`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedSequence`] /// Caused by: passing integer `3` as the sequence argument to `index-of` instead of a list or string. /// Outcome: block accepted. #[test] @@ -396,7 +439,7 @@ fn static_check_error_expected_sequence() { ); } -/// CheckErrorKind: [`CheckErrorKind::CouldNotDetermineSerializationType`] +/// StaticCheckErrorKind: [`StaticCheckErrorKind::CouldNotDetermineSerializationType`] /// Caused by: `to-consensus-buff?` over a list of trait references lacks a serialization type. /// Outcome: block accepted. /// Note: during analysis, this error can only be triggered by `from-consensus-buff?` @@ -405,11 +448,884 @@ fn static_check_error_expected_sequence() { #[test] fn static_check_error_could_not_determine_serialization_type() { contract_deploy_consensus_test!( - contract_name: "serialization-type", - contract_code: " + 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))))", + exclude_clarity_versions: &[ClarityVersion::Clarity1], + ); +} + +/// 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!( + contract_name: "unchecked-resp", + contract_code: " + (define-public (trigger) + (begin + (ok true) + (ok true)))", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchFT`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_no_such_ft() { + contract_deploy_consensus_test!( + contract_name: "no-such-ft", + contract_code: "(ft-get-balance stackoos tx-sender)", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchNFT`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_no_such_nft() { + contract_deploy_consensus_test!( + contract_name: "no-such-nft", + contract_code: r#"(nft-get-owner? stackoos "abc")"#, + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineNFTBadSignature`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_define_nft_bad_signature() { + contract_deploy_consensus_test!( + contract_name: "nft-bad-signature", + contract_code: "(define-non-fungible-token stackaroos integer)", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTokenName`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_bad_token_name() { + contract_deploy_consensus_test!( + contract_name: "bad-token-name", + contract_code: "(ft-get-balance u1234 tx-sender)", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::EmptyTuplesNotAllowed`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_empty_tuples_not_allowed() { + contract_deploy_consensus_test!( + contract_name: "empty-tuples-not", + contract_code: " + (define-private (set-cursor (value (tuple))) + value)", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchDataVariable`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_no_such_data_variable() { + contract_deploy_consensus_test!( + contract_name: "no-such-data-var", + contract_code: " + (define-private (get-cursor) + (unwrap! (var-get cursor) 0))", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NonFunctionApplication`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_non_function_application() { + contract_deploy_consensus_test!( + contract_name: "non-function-appl", + contract_code: "((lambda (x y) 1) 2 1)", + ); +} + +/// 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!( + contract_name: "expected-list-appl", + contract_code: "(append 2 3)", + ); +} + +/// 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!( + contract_name: "no-such-contract", + contract_code: "(contract-call? 'S1G2081040G2081040G2081040G208105NK8PE5.contract-name test! u1)", + ); +} + +/// 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!( + contract_name: "ccall-expect-name", + contract_code: "(contract-call? 'S1G2081040G2081040G2081040G208105NK8PE5.contract-name u1)", + ); +} + +/// 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!( + contract_name: "exp-callable-type", + contract_code: " + (define-constant bad-contract u1) + (contract-call? bad-contract call-me) + ", + ); +} + +/// 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!( + 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()), + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::DefaultTypesMustMatch`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_default_types_must_match() { + contract_deploy_consensus_test!( + 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)))))", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::IfArmsMustMatch`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_if_arms_must_match() { + contract_deploy_consensus_test!( + contract_name: "if-arms-must-match", + contract_code: "(if true true 1)", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::IllegalOrUnknownFunctionApplication`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_illegal_or_unknown_function_application() { + contract_deploy_consensus_test!( + contract_name: "illegal-or-unknown", + contract_code: "(map if (list 1 2 3 4 5))", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::UnknownFunction`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_unknown_function() { + contract_deploy_consensus_test!( + contract_name: "unknown-function", + contract_code: "(ynot 1 2)", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::IncorrectArgumentCount`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_incorrect_argument_count() { + contract_deploy_consensus_test!( + contract_name: "incorrect-arg-count", + contract_code: "(len (list 1) (list 1))", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadLetSyntax`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_bad_let_syntax() { + contract_deploy_consensus_test!( + contract_name: "bad-let-syntax", + contract_code: "(let 1 2)", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadSyntaxBinding`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_bad_syntax_binding() { + contract_deploy_consensus_test!( + contract_name: "bad-syntax-binding", + contract_code: "(let ((1)) (+ 1 2))", + ); +} + +/// 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!( + contract_name: "exp-opt-or-res", + contract_code: "(try! 3)", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::DefineTraitBadSignature`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_define_trait_bad_signature() { + contract_deploy_consensus_test!( + contract_name: "def-trait-bad-sign", + contract_code: "(define-trait trait-1 ((get-1 uint uint)))", + ); +} + +/// 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!( + contract_name: "def-trait-dup-method", + contract_code: " + (define-trait double-method ( + (foo (uint) (response uint uint)) + (foo (bool) (response bool bool)) + ))", + ); +} + +/// 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!( + contract_name: "trait-or-field-ref", + contract_code: "(+ 1 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR.contract.field)", + ); +} + +/// 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!( + 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))", + ); +} + +/// 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!( + 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. +#[test] +fn static_check_error_too_many_function_parameters() { + contract_deploy_consensus_test!( + 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. +/// 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!( + contract_name: "reserved-word", + contract_code: "(define-private (block-height) true)", + ); +} + +/// 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!( + contract_name: "no-such-block-info", + contract_code: "(get-burn-block-info? none u1)", + ); +} + +/// 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!( + contract_name: "no-such-stacks-info", + contract_code: "(get-stacks-block-info? none u1)", + ); +} + +/// 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!( + contract_name: "no-such-tenure-info", + contract_code: "(get-tenure-info? none u1)", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::TraitReferenceUnknown`] +/// Caused by: referenced trait is unknown +/// Outcome: block accepted. +#[test] +fn static_check_error_trait_reference_unknown() { + contract_deploy_consensus_test!( + contract_name: "trait-ref-unknown", + contract_code: "(+ 1 )", + ); +} + +/// 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!( + contract_name: "expect-trait", + contract_code: "(contract-of u1)", + ); +} + +/// 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!( + 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))", ); } + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::WriteAttemptedInReadOnly`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_write_attempted_in_read_only() { + contract_deploy_consensus_test!( + contract_name: "write-attempted-in-ro", + contract_code: " + (define-read-only (silly) + (map-delete map-name (tuple (value 1)))) + (silly)", + ); +} + +/// 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!( + 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)))", + ); +} + +/// 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!( + contract_name: "allow-expr-not-allo", + contract_code: "(with-stx u1)", + ); +} + +/// 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!( + contract_name: "exp-list-of-allowances", + contract_code: "(restrict-assets? tx-sender u1 true)", + ); +} + +/// 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!( + contract_name: "exp-allowa-expr", + contract_code: "(restrict-assets? tx-sender ((not true)) true)", + ); +} + +/// 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!( + contract_name: "all-allow-not-allowed", + contract_code: "(restrict-assets? tx-sender ((with-all-assets-unsafe)) true)", + ); +} + +/// 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!( + contract_name: "all-allow-not-alone", + contract_code: "(as-contract? ((with-all-assets-unsafe) (with-stx u1000)) true)", + ); +} + +/// 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!( + contract_name: "with-nft-exp-ident", + contract_code: r#"(restrict-assets? tx-sender ((with-nft tx-sender "token-name" tx-sender)) true)"#, + ); +} + +/// 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!( + 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(" ") + ), + ); +} + +/// 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!( + contract_name: "too-many-allowances", + contract_code: &format!( + "(restrict-assets? tx-sender ({} ) true)", + std::iter::repeat_n("(with-stx u1)", 130) + .collect::>() + .join(" ") + ), + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::BadTupleConstruction`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_bad_tuple_construction() { + contract_deploy_consensus_test!( + contract_name: "bad-tuple-constr", + contract_code: "(tuple (name 1) (name 2))", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::ExpectedTuple`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_expected_tuple() { + contract_deploy_consensus_test!( + contract_name: "expected-tuple", + contract_code: "(get field-0 (some 1))", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchTupleField`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_no_such_tuple_field() { + contract_deploy_consensus_test!( + contract_name: "no-such-tuple-f", + contract_code: "(get value (tuple (name 1)))", + ); +} + +/// StaticCheckErrorKind: [`StaticCheckErrorKind::NoSuchMap`] +/// Caused by: +/// Outcome: block accepted. +#[test] +fn static_check_error_no_such_map() { + contract_deploy_consensus_test!( + contract_name: "no-such-map", + contract_code: "(map-get? non-existent (tuple (name 1)))", + ); +} + +/// 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!( + contract_name: "bad-func-name", + contract_code: "(define-private (u1) u0)", + ); +} + +/// 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!( + contract_name: "def-func-bad-sign", + contract_code: "(define-private () 1)", + ); +} + +/// 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!( + contract_name: "bad-tuple-field-name", + contract_code: "(get u1 (tuple (foo u0)))", + ); +} + +/// 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!( + contract_name: "bad-map-name", + contract_code: "(map-get? u1 (tuple (id u0)))", + ); +} + +/// 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!( + contract_name: "info-exp-prop-name", + contract_code: "(get-block-info? u1 u0)", + ); +} + +/// 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!( + contract_name: "burn-exp-prop-name", + contract_code: "(get-burn-block-info? u1 u0)", + ); +} + +/// 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!( + contract_name: "stacks-exp-prop-name", + contract_code: "(get-stacks-block-info? u1 u0)", + ); +} + +/// 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!( + contract_name: "tenure-exp-prop-name", + contract_code: "(get-tenure-info? u1 u0)", + ); +} + +/// 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![], epochs_blocks).run(); + + 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), // 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), // 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`] +// 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), [`static_check_error_union_type_error`] +// ExpectedOptionalType(Box), [`static_check_error_expected_optional_type`] +// ExpectedResponseType(Box), [`static_check_error_expected_response_type`] +// 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, [`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, [`static_check_error_could_not_determine_type`] +// 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, [`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), [`static_check_error_bad_tuple_construction`] +// NoSuchDataVariable(String), [`static_check_error_no_such_data_variable`] +// 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), [`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`] +// NoSuchPublicFunction(String, String), [`static_check_error_no_such_public_function`] +// 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`] +// 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`] +// ExpectedListApplication, [`static_check_error_expected_list_application`] +// ExpectedSequence(Box), [`static_check_error_expected_sequence`] +// MaxLengthOverflow, UNREACHABLE: should exceed u32 elements in memory. +// BadLetSyntax, [`static_check_error_bad_let_syntax`] +// BadSyntaxBinding(SyntaxBindingError), [`static_check_error_bad_syntax_binding`] +// 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`] +// 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), [`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`] +// 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), [`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`] +// 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`] +// 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, [`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/clarity_vm/tests/analysis_costs.rs b/stackslib/src/clarity_vm/tests/analysis_costs.rs index 45b03e4f5b6..183b3abb21a 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}; @@ -320,7 +320,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); diff --git a/stackslib/src/clarity_vm/tests/large_contract.rs b/stackslib/src/clarity_vm/tests/large_contract.rs index 06a154ffd1d..dc35a56507d 100644 --- a/stackslib/src/clarity_vm/tests/large_contract.rs +++ b/stackslib/src/clarity_vm/tests/large_contract.rs @@ -71,7 +71,7 @@ const SIMPLE_TOKENS: &str = "(define-map tokens { account: principal } { balance (token-credit! to amount))))) (define-public (faucet) (let ((original-sender tx-sender)) - (as-contract (print (token-transfer (print original-sender) u1))))) + (as-contract (print (token-transfer (print original-sender) u1))))) (define-public (mint-after (block-to-release uint)) (if (>= block-height block-to-release) (faucet) @@ -512,7 +512,7 @@ fn inner_test_simple_naming_system(owned_env: &mut OwnedEnvironment, version: Cl \"not enough balance\") (err 1) (err 3))))) - (define-public (register + (define-public (register (recipient-principal principal) (name int) (salt int))