diff --git a/.github/workflows/cargo-hack-check.yml b/.github/workflows/cargo-hack-check.yml
index c1f208562d..7fff9a2873 100644
--- a/.github/workflows/cargo-hack-check.yml
+++ b/.github/workflows/cargo-hack-check.yml
@@ -78,11 +78,12 @@ jobs:
- name: "Clarity & Stacks-Common WASM Web"
command: |
cargo hack check \
+ -p clarity \
-p clarity-serialization \
-p stacks-common \
--each-feature \
--no-dev-deps \
- --exclude-features=default,rusqlite,ctrlc-handler,wasm-deterministic \
+ --exclude-features=default,rusqlite,ctrlc-handler,wasm-deterministic,testing \
--features=wasm-web
- name: "Clarity & Stacks-Common WASM Deterministic"
diff --git a/Cargo.lock b/Cargo.lock
index f7c0905f54..0ab32a2dec 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -605,7 +605,7 @@ name = "clarity"
version = "0.0.1"
dependencies = [
"assert-json-diff 1.1.0",
- "hashbrown 0.15.2",
+ "clarity-serialization",
"integer-sqrt",
"lazy_static",
"mutants",
@@ -652,11 +652,12 @@ dependencies = [
"mutants",
"regex",
"rstest",
+ "rusqlite",
"serde",
"serde_derive",
+ "serde_json",
"slog",
"stacks-common 0.0.1",
- "thiserror",
]
[[package]]
@@ -3356,7 +3357,6 @@ dependencies = [
"chrono",
"clarity 0.0.1",
"ed25519-dalek",
- "hashbrown 0.15.2",
"lazy_static",
"libstackerdb 0.0.1",
"mio 0.6.23",
diff --git a/clarity-serialization/Cargo.toml b/clarity-serialization/Cargo.toml
index 341d8c0c29..f7518e3a18 100644
--- a/clarity-serialization/Cargo.toml
+++ b/clarity-serialization/Cargo.toml
@@ -12,11 +12,12 @@ readme = "README.md"
[dependencies]
lazy_static = { workspace = true }
regex = { version = "1", default-features = false }
+rusqlite = { workspace = true, optional = true }
serde = { workspace = true }
+serde_json = { version = "1.0", default-features = false }
serde_derive = { workspace = true }
slog = { workspace = true }
stacks_common = { package = "stacks-common", path = "../stacks-common", default-features = false }
-thiserror = { workspace = true }
[dev-dependencies]
mutants = "0.0.3"
@@ -25,7 +26,9 @@ rstest = "0.17.0"
[features]
default = []
testing = []
+developer-mode = ["stacks_common/developer-mode"]
slog_json = ["stacks_common/slog_json"]
+rusqlite = ["stacks_common/rusqlite", "dep:rusqlite"]
# Wasm-specific features for easier configuration
wasm-web = ["stacks_common/wasm-web"]
diff --git a/clarity-serialization/src/diagnostic.rs b/clarity-serialization/src/diagnostic.rs
new file mode 100644
index 0000000000..c8aeda8e6c
--- /dev/null
+++ b/clarity-serialization/src/diagnostic.rs
@@ -0,0 +1,90 @@
+// 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 .
+
+use std::fmt;
+
+use crate::representations::Span;
+
+/// In a near future, we can go further in our static analysis and provide different levels
+/// of diagnostics, such as warnings, hints, best practices, etc.
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+pub enum Level {
+ Note,
+ Warning,
+ Error,
+}
+
+pub trait DiagnosableError {
+ fn message(&self) -> String;
+ fn suggestion(&self) -> Option;
+ fn level(&self) -> Level {
+ Level::Error
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct Diagnostic {
+ pub level: Level,
+ pub message: String,
+ pub spans: Vec,
+ pub suggestion: Option,
+}
+
+impl Diagnostic {
+ pub fn err(error: &dyn DiagnosableError) -> Diagnostic {
+ Diagnostic {
+ spans: vec![],
+ level: Level::Error,
+ message: error.message(),
+ suggestion: error.suggestion(),
+ }
+ }
+
+ pub fn add_span(&mut self, start_line: u32, start_column: u32, end_line: u32, end_column: u32) {
+ self.spans.push(Span {
+ start_line,
+ start_column,
+ end_line,
+ end_column,
+ });
+ }
+}
+
+impl fmt::Display for Diagnostic {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{:?}", self.level)?;
+ match self.spans.len().cmp(&1) {
+ std::cmp::Ordering::Equal => write!(
+ f,
+ " (line {}, column {})",
+ self.spans[0].start_line, self.spans[0].start_column
+ )?,
+ std::cmp::Ordering::Greater => {
+ let lines: Vec = self
+ .spans
+ .iter()
+ .map(|s| format!("line: {}", s.start_line))
+ .collect();
+ write!(f, " ({})", lines.join(", "))?;
+ }
+ _ => {}
+ }
+ write!(f, ": {}.", &self.message)?;
+ if let Some(suggestion) = &self.suggestion {
+ write!(f, "\n{suggestion}")?;
+ }
+ writeln!(f)
+ }
+}
diff --git a/clarity-serialization/src/errors.rs b/clarity-serialization/src/errors.rs
deleted file mode 100644
index c0b6428a82..0000000000
--- a/clarity-serialization/src/errors.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-// 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 .
-
-use std::io;
-
-use thiserror::Error;
-
-use crate::types::{TupleTypeSignature, TypeSignature, Value};
-
-/// The primary error type for the `clarity-codec` crate.
-///
-/// It represents all possible failures that can occur when encoding, decoding,
-/// or validating the structure and types of a Clarity value.
-#[derive(Error, Debug)]
-pub enum CodecError {
- #[error("I/O error during (de)serialization: {0}")]
- Io(#[from] io::Error),
-
- #[error("Serialization error caused by IO: {0}")]
- Serialization(String),
-
- #[error("Deserialization failed: {0}")]
- Deserialization(String),
-
- #[error("Deserialization expected the type of the input to be: {0}")]
- DeserializeExpected(Box),
-
- #[error("The serializer handled an input in an unexpected way")]
- UnexpectedSerialization,
-
- #[error("Deserialization finished but there were leftover bytes in the buffer")]
- LeftoverBytesInDeserialization,
-
- #[error("Parse error: {0}")]
- ParseError(String),
-
- #[error("Bad type construction.")]
- BadTypeConstruction,
-
- // --- Structural and Size Errors ---
- #[error("A value being constructed is larger than the 1MB Clarity limit")]
- ValueTooLarge,
-
- #[error("A value is out of its prescribed bounds")]
- ValueOutOfBounds,
-
- #[error("A type signature is deeper than the 32-level Clarity limit")]
- TypeSignatureTooDeep,
-
- #[error("The supertype of two types is too large to be represented")]
- SupertypeTooLarge,
-
- #[error("Empty tuples are not allowed")]
- EmptyTuplesNotAllowed,
-
- #[error("Failed to construct a tuple with the given type")]
- FailureConstructingTupleWithType,
-
- #[error("Failed to construct a list with the given type")]
- FailureConstructingListWithType,
-
- #[error("All elements in a list must have a compatible supertype")]
- ListTypesMustMatch,
-
- // --- Type Mismatch and Semantic Errors ---
- #[error("Expected a value of type '{expected}', but found a value of type '{found}'")]
- TypeError {
- expected: Box,
- found: Box,
- },
-
- #[error("Expected a value of type '{expected}', but found the value '{found}'")]
- TypeValueError {
- expected: Box,
- found: Box,
- },
-
- #[error("could not determine the input type for the serialization function")]
- CouldNotDetermineSerializationType,
-
- #[error("type of expression cannot be determined")]
- CouldNotDetermineType,
-
- // --- Naming and Identifier Errors ---
- #[error("Name '{0}' is already used in this tuple")]
- NameAlreadyUsedInTuple(String),
-
- #[error("Could not find field '{0}' in tuple '{1}'")]
- NoSuchTupleField(String, TupleTypeSignature),
-
- #[error("Failed to parse {0}: {1}")]
- InvalidClarityName(&'static str, String),
-
- #[error("Failed to parse {0}: {1}")]
- InvalidContractName(&'static str, String),
-
- // --- String/Buffer Content Errors ---
- #[error("Invalid characters detected in string")]
- InvalidStringCharacters,
-
- #[error("Invalid UTF-8 encoding in string")]
- InvalidUtf8Encoding,
-
- // --- Catch-all for internal logic errors ---
- #[error("An unexpected internal error occurred: {0}")]
- Expect(String),
-}
-
-// Implement PartialEq for testing and simple equality checks by comparing the
-// string representations of each error. This avoids requiring all wrapped
-// fields (like `std::io::Error`) to implement PartialEq.
-#[cfg(any(test, feature = "testing"))]
-impl PartialEq for CodecError {
- fn eq(&self, other: &Self) -> bool {
- self.to_string() == other.to_string()
- }
-}
diff --git a/clarity-serialization/src/errors/analysis.rs b/clarity-serialization/src/errors/analysis.rs
new file mode 100644
index 0000000000..8831198579
--- /dev/null
+++ b/clarity-serialization/src/errors/analysis.rs
@@ -0,0 +1,505 @@
+// 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 .
+
+use std::{error, fmt};
+
+use crate::diagnostic::{DiagnosableError, Diagnostic};
+use crate::errors::CostErrors;
+use crate::execution_cost::ExecutionCost;
+use crate::representations::SymbolicExpression;
+use crate::types::{TraitIdentifier, TupleTypeSignature, TypeSignature, Value};
+
+pub type CheckResult = Result;
+
+#[derive(Debug, PartialEq)]
+pub enum CheckErrors {
+ // cost checker errors
+ CostOverflow,
+ CostBalanceExceeded(ExecutionCost, ExecutionCost),
+ MemoryBalanceExceeded(u64, u64),
+ CostComputationFailed(String),
+
+ ValueTooLarge,
+ ValueOutOfBounds,
+ TypeSignatureTooDeep,
+ ExpectedName,
+ SupertypeTooLarge,
+
+ // unexpected interpreter behavior
+ Expects(String),
+
+ // match errors
+ BadMatchOptionSyntax(Box),
+ BadMatchResponseSyntax(Box),
+ BadMatchInput(TypeSignature),
+
+ // list typing errors
+ UnknownListConstructionFailure,
+ ListTypesMustMatch,
+ ConstructedListTooLarge,
+
+ // simple type expectation mismatch
+ TypeError(TypeSignature, TypeSignature),
+ TypeLiteralError(TypeSignature, TypeSignature),
+ TypeValueError(TypeSignature, Value),
+
+ NoSuperType(TypeSignature, TypeSignature),
+ InvalidTypeDescription,
+ UnknownTypeName(String),
+
+ // union type mismatch
+ UnionTypeError(Vec, TypeSignature),
+ UnionTypeValueError(Vec, Value),
+
+ ExpectedLiteral,
+ ExpectedOptionalType(TypeSignature),
+ ExpectedResponseType(TypeSignature),
+ ExpectedOptionalOrResponseType(TypeSignature),
+ ExpectedOptionalValue(Value),
+ ExpectedResponseValue(Value),
+ ExpectedOptionalOrResponseValue(Value),
+ CouldNotDetermineResponseOkType,
+ CouldNotDetermineResponseErrType,
+ CouldNotDetermineSerializationType,
+ UncheckedIntermediaryResponses,
+
+ CouldNotDetermineMatchTypes,
+ CouldNotDetermineType,
+
+ // Checker runtime failures
+ TypeAlreadyAnnotatedFailure,
+ TypeAnnotationExpectedFailure,
+ CheckerImplementationFailure,
+
+ // Assets
+ BadTokenName,
+ DefineFTBadSignature,
+ DefineNFTBadSignature,
+ NoSuchNFT(String),
+ NoSuchFT(String),
+
+ BadTransferSTXArguments,
+ BadTransferFTArguments,
+ BadTransferNFTArguments,
+ BadMintFTArguments,
+ BadBurnFTArguments,
+
+ // tuples
+ BadTupleFieldName,
+ ExpectedTuple(TypeSignature),
+ NoSuchTupleField(String, TupleTypeSignature),
+ EmptyTuplesNotAllowed,
+ BadTupleConstruction,
+ TupleExpectsPairs,
+
+ // variables
+ NoSuchDataVariable(String),
+
+ // data map
+ BadMapName,
+ NoSuchMap(String),
+
+ // defines
+ DefineFunctionBadSignature,
+ BadFunctionName,
+ BadMapTypeDefinition,
+ PublicFunctionMustReturnResponse(TypeSignature),
+ DefineVariableBadSignature,
+ ReturnTypesMustMatch(TypeSignature, TypeSignature),
+
+ CircularReference(Vec),
+
+ // contract-call errors
+ NoSuchContract(String),
+ NoSuchPublicFunction(String, String),
+ PublicFunctionNotReadOnly(String, String),
+ ContractAlreadyExists(String),
+ ContractCallExpectName,
+ ExpectedCallableType(TypeSignature),
+
+ // get-block-info? errors
+ NoSuchBlockInfoProperty(String),
+ NoSuchBurnBlockInfoProperty(String),
+ NoSuchStacksBlockInfoProperty(String),
+ NoSuchTenureInfoProperty(String),
+ GetBlockInfoExpectPropertyName,
+ GetBurnBlockInfoExpectPropertyName,
+ GetStacksBlockInfoExpectPropertyName,
+ GetTenureInfoExpectPropertyName,
+
+ NameAlreadyUsed(String),
+ ReservedWord(String),
+
+ // expect a function, or applying a function to a list
+ NonFunctionApplication,
+ ExpectedListApplication,
+ ExpectedSequence(TypeSignature),
+ MaxLengthOverflow,
+
+ // let syntax
+ BadLetSyntax,
+
+ // generic binding syntax
+ BadSyntaxBinding,
+ BadSyntaxExpectedListOfPairs,
+
+ MaxContextDepthReached,
+ UndefinedFunction(String),
+ UndefinedVariable(String),
+
+ // argument counts
+ RequiresAtLeastArguments(usize, usize),
+ RequiresAtMostArguments(usize, usize),
+ IncorrectArgumentCount(usize, usize),
+ IfArmsMustMatch(TypeSignature, TypeSignature),
+ MatchArmsMustMatch(TypeSignature, TypeSignature),
+ DefaultTypesMustMatch(TypeSignature, TypeSignature),
+ TooManyExpressions,
+ IllegalOrUnknownFunctionApplication(String),
+ UnknownFunction(String),
+
+ // traits
+ NoSuchTrait(String, String),
+ TraitReferenceUnknown(String),
+ TraitMethodUnknown(String, String),
+ ExpectedTraitIdentifier,
+ ImportTraitBadSignature,
+ TraitReferenceNotAllowed,
+ BadTraitImplementation(String, String),
+ DefineTraitBadSignature,
+ DefineTraitDuplicateMethod(String),
+ UnexpectedTraitOrFieldReference,
+ TraitBasedContractCallInReadOnly,
+ ContractOfExpectsTrait,
+ IncompatibleTrait(TraitIdentifier, TraitIdentifier),
+
+ // strings
+ InvalidCharactersDetected,
+ InvalidUTF8Encoding,
+
+ // secp256k1 signature
+ InvalidSecp65k1Signature,
+
+ WriteAttemptedInReadOnly,
+ AtBlockClosureMustBeReadOnly,
+
+ // time checker errors
+ ExecutionTimeExpired,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct CheckError {
+ pub err: CheckErrors,
+ pub expressions: Option>,
+ pub diagnostic: Diagnostic,
+}
+
+impl CheckErrors {
+ /// Does this check error indicate that the transaction should be
+ /// rejected?
+ pub fn rejectable(&self) -> bool {
+ matches!(
+ self,
+ CheckErrors::SupertypeTooLarge | CheckErrors::Expects(_)
+ )
+ }
+}
+
+impl CheckError {
+ pub fn new(err: CheckErrors) -> CheckError {
+ let diagnostic = Diagnostic::err(&err);
+ CheckError {
+ err,
+ expressions: None,
+ diagnostic,
+ }
+ }
+
+ pub fn has_expression(&self) -> bool {
+ self.expressions.is_some()
+ }
+
+ pub fn set_expression(&mut self, expr: &SymbolicExpression) {
+ self.diagnostic.spans = vec![expr.span().clone()];
+ self.expressions.replace(vec![expr.clone()]);
+ }
+
+ pub fn set_expressions(&mut self, exprs: &[SymbolicExpression]) {
+ self.diagnostic.spans = exprs.iter().map(|e| e.span().clone()).collect();
+ self.expressions.replace(exprs.to_vec());
+ }
+}
+
+impl fmt::Display for CheckErrors {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{self:?}")
+ }
+}
+
+impl fmt::Display for CheckError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}", self.err)?;
+
+ if let Some(ref e) = self.expressions {
+ write!(f, "\nNear:\n{e:?}")?;
+ }
+
+ Ok(())
+ }
+}
+
+impl From for CheckError {
+ fn from(err: CostErrors) -> Self {
+ CheckError::from(CheckErrors::from(err))
+ }
+}
+
+impl From for CheckErrors {
+ fn from(err: CostErrors) -> Self {
+ match err {
+ CostErrors::CostOverflow => CheckErrors::CostOverflow,
+ CostErrors::CostBalanceExceeded(a, b) => CheckErrors::CostBalanceExceeded(a, b),
+ CostErrors::MemoryBalanceExceeded(a, b) => CheckErrors::MemoryBalanceExceeded(a, b),
+ CostErrors::CostComputationFailed(s) => CheckErrors::CostComputationFailed(s),
+ CostErrors::CostContractLoadFailure => {
+ CheckErrors::CostComputationFailed("Failed to load cost contract".into())
+ }
+ CostErrors::InterpreterFailure => {
+ CheckErrors::Expects("Unexpected interpreter failure in cost computation".into())
+ }
+ CostErrors::Expect(s) => CheckErrors::Expects(s),
+ CostErrors::ExecutionTimeExpired => CheckErrors::ExecutionTimeExpired,
+ }
+ }
+}
+
+impl error::Error for CheckError {
+ fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+ None
+ }
+}
+
+impl error::Error for CheckErrors {
+ fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+ None
+ }
+}
+
+impl From for CheckError {
+ fn from(err: CheckErrors) -> Self {
+ CheckError::new(err)
+ }
+}
+
+#[cfg(any(test, feature = "testing"))]
+impl From for String {
+ fn from(o: CheckErrors) -> Self {
+ o.to_string()
+ }
+}
+
+#[allow(clippy::result_large_err)]
+pub fn check_argument_count(expected: usize, args: &[T]) -> Result<(), CheckErrors> {
+ if args.len() != expected {
+ Err(CheckErrors::IncorrectArgumentCount(expected, args.len()))
+ } else {
+ Ok(())
+ }
+}
+
+#[allow(clippy::result_large_err)]
+pub fn check_arguments_at_least(expected: usize, args: &[T]) -> Result<(), CheckErrors> {
+ if args.len() < expected {
+ Err(CheckErrors::RequiresAtLeastArguments(expected, args.len()))
+ } else {
+ Ok(())
+ }
+}
+
+#[allow(clippy::result_large_err)]
+pub fn check_arguments_at_most(expected: usize, args: &[T]) -> Result<(), CheckErrors> {
+ if args.len() > expected {
+ Err(CheckErrors::RequiresAtMostArguments(expected, args.len()))
+ } else {
+ Ok(())
+ }
+}
+
+fn formatted_expected_types(expected_types: &[TypeSignature]) -> String {
+ let mut expected_types_joined = format!("'{}'", expected_types[0]);
+
+ if expected_types.len() > 2 {
+ for expected_type in expected_types[1..expected_types.len() - 1].iter() {
+ expected_types_joined.push_str(&format!(", '{expected_type}'"));
+ }
+ }
+ expected_types_joined.push_str(&format!(
+ " or '{}'",
+ expected_types[expected_types.len() - 1]
+ ));
+ expected_types_joined
+}
+
+impl DiagnosableError for CheckErrors {
+ fn message(&self) -> String {
+ match &self {
+ CheckErrors::ExpectedLiteral => "expected a literal argument".into(),
+ CheckErrors::SupertypeTooLarge => "supertype of two types is too large".into(),
+ CheckErrors::Expects(s) => format!("unexpected interpreter behavior: {s}"),
+ CheckErrors::BadMatchOptionSyntax(source) =>
+ format!("match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: {}",
+ source.message()),
+ CheckErrors::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()),
+ CheckErrors::BadMatchInput(t) =>
+ format!("match requires an input of either a response or optional, found input: '{t}'"),
+ CheckErrors::TypeAnnotationExpectedFailure => "analysis expected type to already be annotated for expression".into(),
+ CheckErrors::CostOverflow => "contract execution cost overflowed cost counter".into(),
+ CheckErrors::CostBalanceExceeded(a, b) => format!("contract execution cost exceeded budget: {a:?} > {b:?}"),
+ CheckErrors::MemoryBalanceExceeded(a, b) => format!("contract execution cost exceeded memory budget: {a:?} > {b:?}"),
+ CheckErrors::InvalidTypeDescription => "supplied type description is invalid".into(),
+ CheckErrors::EmptyTuplesNotAllowed => "tuple types may not be empty".into(),
+ CheckErrors::BadSyntaxExpectedListOfPairs => "bad syntax: function expects a list of pairs to bind names, e.g., ((name-0 a) (name-1 b) ...)".into(),
+ CheckErrors::UnknownTypeName(name) => format!("failed to parse type: '{name}'"),
+ CheckErrors::ValueTooLarge => "created a type which was greater than maximum allowed value size".into(),
+ CheckErrors::ValueOutOfBounds => "created a type which value size was out of defined bounds".into(),
+ CheckErrors::TypeSignatureTooDeep => "created a type which was deeper than maximum allowed type depth".into(),
+ CheckErrors::ExpectedName => "expected a name argument to this function".into(),
+ CheckErrors::NoSuperType(a, b) => format!("unable to create a supertype for the two types: '{a}' and '{b}'"),
+ CheckErrors::UnknownListConstructionFailure => "invalid syntax for list definition".into(),
+ CheckErrors::ListTypesMustMatch => "expecting elements of same type in a list".into(),
+ CheckErrors::ConstructedListTooLarge => "reached limit of elements in a sequence".into(),
+ CheckErrors::TypeError(expected_type, found_type) => format!("expecting expression of type '{expected_type}', found '{found_type}'"),
+ CheckErrors::TypeLiteralError(expected_type, found_type) => format!("expecting a literal of type '{expected_type}', found '{found_type}'"),
+ CheckErrors::TypeValueError(expected_type, found_value) => format!("expecting expression of type '{expected_type}', found '{found_value}'"),
+ CheckErrors::UnionTypeError(expected_types, found_type) => format!("expecting expression of type {}, found '{}'", formatted_expected_types(expected_types), found_type),
+ CheckErrors::UnionTypeValueError(expected_types, found_type) => format!("expecting expression of type {}, found '{}'", formatted_expected_types(expected_types), found_type),
+ CheckErrors::ExpectedOptionalType(found_type) => format!("expecting expression of type 'optional', found '{found_type}'"),
+ CheckErrors::ExpectedOptionalOrResponseType(found_type) => format!("expecting expression of type 'optional' or 'response', found '{found_type}'"),
+ CheckErrors::ExpectedOptionalOrResponseValue(found_type) => format!("expecting expression of type 'optional' or 'response', found '{found_type}'"),
+ CheckErrors::ExpectedResponseType(found_type) => format!("expecting expression of type 'response', found '{found_type}'"),
+ CheckErrors::ExpectedOptionalValue(found_type) => format!("expecting expression of type 'optional', found '{found_type}'"),
+ CheckErrors::ExpectedResponseValue(found_type) => format!("expecting expression of type 'response', found '{found_type}'"),
+ CheckErrors::CouldNotDetermineResponseOkType => "attempted to obtain 'ok' value from response, but 'ok' type is indeterminate".into(),
+ CheckErrors::CouldNotDetermineResponseErrType => "attempted to obtain 'err' value from response, but 'err' type is indeterminate".into(),
+ CheckErrors::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(),
+ CheckErrors::CouldNotDetermineType => "type of expression cannot be determined".into(),
+ CheckErrors::BadTupleFieldName => "invalid tuple field name".into(),
+ CheckErrors::ExpectedTuple(type_signature) => format!("expecting tuple, found '{type_signature}'"),
+ CheckErrors::NoSuchTupleField(field_name, tuple_signature) => format!("cannot find field '{field_name}' in tuple '{tuple_signature}'"),
+ CheckErrors::BadTupleConstruction => "invalid tuple syntax, expecting list of pair".into(),
+ CheckErrors::TupleExpectsPairs => "invalid tuple syntax, expecting pair".into(),
+ CheckErrors::NoSuchDataVariable(var_name) => format!("use of unresolved persisted variable '{var_name}'"),
+ CheckErrors::BadTransferSTXArguments => "STX transfer expects an int amount, from principal, to principal".into(),
+ CheckErrors::BadTransferFTArguments => "transfer expects an int amount, from principal, to principal".into(),
+ CheckErrors::BadTransferNFTArguments => "transfer expects an asset, from principal, to principal".into(),
+ CheckErrors::BadMintFTArguments => "mint expects a uint amount and from principal".into(),
+ CheckErrors::BadBurnFTArguments => "burn expects a uint amount and from principal".into(),
+ CheckErrors::BadMapName => "invalid map name".into(),
+ CheckErrors::NoSuchMap(map_name) => format!("use of unresolved map '{map_name}'"),
+ CheckErrors::DefineFunctionBadSignature => "invalid function definition".into(),
+ CheckErrors::BadFunctionName => "invalid function name".into(),
+ CheckErrors::BadMapTypeDefinition => "invalid map definition".into(),
+ CheckErrors::PublicFunctionMustReturnResponse(found_type) => format!("public functions must return an expression of type 'response', found '{found_type}'"),
+ CheckErrors::DefineVariableBadSignature => "invalid variable definition".into(),
+ CheckErrors::ReturnTypesMustMatch(type_1, type_2) => format!("detected two execution paths, returning two different expression types (got '{type_1}' and '{type_2}')"),
+ CheckErrors::NoSuchContract(contract_identifier) => format!("use of unresolved contract '{contract_identifier}'"),
+ CheckErrors::NoSuchPublicFunction(contract_identifier, function_name) => format!("contract '{contract_identifier}' has no public function '{function_name}'"),
+ CheckErrors::PublicFunctionNotReadOnly(contract_identifier, function_name) => format!("function '{contract_identifier}' in '{function_name}' is not read-only"),
+ CheckErrors::ContractAlreadyExists(contract_identifier) => format!("contract name '{contract_identifier}' conflicts with existing contract"),
+ CheckErrors::ContractCallExpectName => "missing contract name for call".into(),
+ CheckErrors::ExpectedCallableType(found_type) => format!("expected a callable contract, found {found_type}"),
+ CheckErrors::NoSuchBlockInfoProperty(property_name) => format!("use of block unknown property '{property_name}'"),
+ CheckErrors::NoSuchBurnBlockInfoProperty(property_name) => format!("use of burn block unknown property '{property_name}'"),
+ CheckErrors::NoSuchStacksBlockInfoProperty(property_name) => format!("use of unknown stacks block property '{property_name}'"),
+ CheckErrors::NoSuchTenureInfoProperty(property_name) => format!("use of unknown tenure property '{property_name}'"),
+ CheckErrors::GetBlockInfoExpectPropertyName => "missing property name for block info introspection".into(),
+ CheckErrors::GetBurnBlockInfoExpectPropertyName => "missing property name for burn block info introspection".into(),
+ CheckErrors::GetStacksBlockInfoExpectPropertyName => "missing property name for stacks block info introspection".into(),
+ CheckErrors::GetTenureInfoExpectPropertyName => "missing property name for tenure info introspection".into(),
+ CheckErrors::NameAlreadyUsed(name) => format!("defining '{name}' conflicts with previous value"),
+ CheckErrors::ReservedWord(name) => format!("{name} is a reserved word"),
+ CheckErrors::NonFunctionApplication => "expecting expression of type function".into(),
+ CheckErrors::ExpectedListApplication => "expecting expression of type list".into(),
+ CheckErrors::ExpectedSequence(found_type) => format!("expecting expression of type 'list', 'buff', 'string-ascii' or 'string-utf8' - found '{found_type}'"),
+ CheckErrors::MaxLengthOverflow => format!("expecting a value <= {}", u32::MAX),
+ CheckErrors::BadLetSyntax => "invalid syntax of 'let'".into(),
+ CheckErrors::CircularReference(references) => format!("detected circular reference: ({})", references.join(", ")),
+ CheckErrors::BadSyntaxBinding => "invalid syntax binding".into(),
+ CheckErrors::MaxContextDepthReached => "reached depth limit".into(),
+ CheckErrors::UndefinedVariable(var_name) => format!("use of unresolved variable '{var_name}'"),
+ CheckErrors::UndefinedFunction(var_name) => format!("use of unresolved function '{var_name}'"),
+ CheckErrors::RequiresAtLeastArguments(expected, found) => format!("expecting >= {expected} arguments, got {found}"),
+ CheckErrors::RequiresAtMostArguments(expected, found) => format!("expecting < {expected} arguments, got {found}"),
+ CheckErrors::IncorrectArgumentCount(expected_count, found_count) => format!("expecting {expected_count} arguments, got {found_count}"),
+ CheckErrors::IfArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'if' must match (got '{type_1}' and '{type_2}')"),
+ CheckErrors::MatchArmsMustMatch(type_1, type_2) => format!("expression types returned by the arms of 'match' must match (got '{type_1}' and '{type_2}')"),
+ CheckErrors::DefaultTypesMustMatch(type_1, type_2) => format!("expression types passed in 'default-to' must match (got '{type_1}' and '{type_2}')"),
+ CheckErrors::TooManyExpressions => "reached limit of expressions".into(),
+ CheckErrors::IllegalOrUnknownFunctionApplication(function_name) => format!("use of illegal / unresolved function '{function_name}"),
+ CheckErrors::UnknownFunction(function_name) => format!("use of unresolved function '{function_name}'"),
+ CheckErrors::TraitBasedContractCallInReadOnly => "use of trait based contract calls are not allowed in read-only context".into(),
+ CheckErrors::WriteAttemptedInReadOnly => "expecting read-only statements, detected a writing operation".into(),
+ CheckErrors::AtBlockClosureMustBeReadOnly => "(at-block ...) closures expect read-only statements, but detected a writing operation".into(),
+ CheckErrors::BadTokenName => "expecting an token name as an argument".into(),
+ CheckErrors::DefineFTBadSignature => "(define-token ...) expects a token name as an argument".into(),
+ CheckErrors::DefineNFTBadSignature => "(define-asset ...) expects an asset name and an asset identifier type signature as arguments".into(),
+ CheckErrors::NoSuchNFT(asset_name) => format!("tried to use asset function with a undefined asset ('{asset_name}')"),
+ CheckErrors::NoSuchFT(asset_name) => format!("tried to use token function with a undefined token ('{asset_name}')"),
+ CheckErrors::NoSuchTrait(contract_name, trait_name) => format!("use of unresolved trait {contract_name}.{trait_name}"),
+ CheckErrors::TraitReferenceUnknown(trait_name) => format!("use of undeclared trait <{trait_name}>"),
+ CheckErrors::TraitMethodUnknown(trait_name, func_name) => format!("method '{func_name}' unspecified in trait <{trait_name}>"),
+ CheckErrors::ImportTraitBadSignature => "(use-trait ...) expects a trait name and a trait identifier".into(),
+ CheckErrors::BadTraitImplementation(trait_name, func_name) => format!("invalid signature for method '{func_name}' regarding trait's specification <{trait_name}>"),
+ CheckErrors::ExpectedTraitIdentifier => "expecting expression of type trait identifier".into(),
+ CheckErrors::UnexpectedTraitOrFieldReference => "unexpected use of trait reference or field".into(),
+ CheckErrors::DefineTraitBadSignature => "invalid trait definition".into(),
+ CheckErrors::DefineTraitDuplicateMethod(method_name) => format!("duplicate method name '{method_name}' in trait definition"),
+ CheckErrors::TraitReferenceNotAllowed => "trait references can not be stored".into(),
+ CheckErrors::ContractOfExpectsTrait => "trait reference expected".into(),
+ CheckErrors::IncompatibleTrait(expected_trait, actual_trait) => format!("trait '{actual_trait}' is not a compatible with expected trait, '{expected_trait}'"),
+ CheckErrors::InvalidCharactersDetected => "invalid characters detected".into(),
+ CheckErrors::InvalidUTF8Encoding => "invalid UTF8 encoding".into(),
+ CheckErrors::InvalidSecp65k1Signature => "invalid seckp256k1 signature".into(),
+ CheckErrors::TypeAlreadyAnnotatedFailure | CheckErrors::CheckerImplementationFailure => {
+ "internal error - please file an issue on https://github.com/stacks-network/stacks-blockchain".into()
+ },
+ CheckErrors::UncheckedIntermediaryResponses => "intermediary responses in consecutive statements must be checked".into(),
+ CheckErrors::CostComputationFailed(s) => format!("contract cost computation failed: {s}"),
+ CheckErrors::CouldNotDetermineSerializationType => "could not determine the input type for the serialization function".into(),
+ CheckErrors::ExecutionTimeExpired => "execution time expired".into(),
+ }
+ }
+
+ fn suggestion(&self) -> Option {
+ match &self {
+ CheckErrors::BadSyntaxBinding => {
+ Some("binding syntax example: ((supply int) (ttl int))".into())
+ }
+ CheckErrors::BadLetSyntax => Some(
+ "'let' syntax example: (let ((supply 1000) (ttl 60)) )".into(),
+ ),
+ CheckErrors::TraitReferenceUnknown(_) => Some(
+ "traits should be either defined, with define-trait, or imported, with use-trait."
+ .into(),
+ ),
+ CheckErrors::NoSuchBlockInfoProperty(_) => Some(
+ "properties available: time, header-hash, burnchain-header-hash, vrf-seed".into(),
+ ),
+ _ => None,
+ }
+ }
+}
diff --git a/clarity-serialization/src/errors/ast.rs b/clarity-serialization/src/errors/ast.rs
new file mode 100644
index 0000000000..35ee8fca2d
--- /dev/null
+++ b/clarity-serialization/src/errors/ast.rs
@@ -0,0 +1,319 @@
+// 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 .
+
+use std::{error, fmt};
+
+use crate::MAX_CALL_STACK_DEPTH;
+use crate::diagnostic::{DiagnosableError, Diagnostic, Level};
+use crate::errors::{CostErrors, LexerError};
+use crate::execution_cost::ExecutionCost;
+use crate::representations::{PreSymbolicExpression, Span};
+use crate::token::Token;
+
+pub type ParseResult = Result;
+
+#[derive(Debug, PartialEq)]
+pub enum ParseErrors {
+ CostOverflow,
+ CostBalanceExceeded(ExecutionCost, ExecutionCost),
+ MemoryBalanceExceeded(u64, u64),
+ TooManyExpressions,
+ ExpressionStackDepthTooDeep,
+ VaryExpressionStackDepthTooDeep,
+ FailedCapturingInput,
+ SeparatorExpected(String),
+ SeparatorExpectedAfterColon(String),
+ ProgramTooLarge,
+ IllegalVariableName(String),
+ IllegalContractName(String),
+ UnknownQuotedValue(String),
+ FailedParsingIntValue(String),
+ FailedParsingUIntValue(String),
+ FailedParsingBuffer(String),
+ FailedParsingHexValue(String, String),
+ FailedParsingPrincipal(String),
+ FailedParsingField(String),
+ FailedParsingRemainder(String),
+ ClosingParenthesisUnexpected,
+ ClosingParenthesisExpected,
+ ClosingTupleLiteralUnexpected,
+ ClosingTupleLiteralExpected,
+ CircularReference(Vec),
+ TupleColonExpected(usize),
+ TupleCommaExpected(usize),
+ TupleItemExpected(usize),
+ NameAlreadyUsed(String),
+ TraitReferenceNotAllowed,
+ ImportTraitBadSignature,
+ DefineTraitBadSignature,
+ ImplTraitBadSignature,
+ TraitReferenceUnknown(String),
+ CommaSeparatorUnexpected,
+ ColonSeparatorUnexpected,
+ InvalidCharactersDetected,
+ InvalidEscaping,
+ CostComputationFailed(String),
+
+ // V2 Errors
+ Lexer(LexerError),
+ ContractNameTooLong(String),
+ ExpectedContractIdentifier,
+ ExpectedTraitIdentifier,
+ IllegalTraitName(String),
+ InvalidPrincipalLiteral,
+ InvalidBuffer,
+ NameTooLong(String),
+ UnexpectedToken(Token),
+ ExpectedClosing(Token),
+ TupleColonExpectedv2,
+ TupleCommaExpectedv2,
+ TupleValueExpected,
+ IllegalClarityName(String),
+ IllegalASCIIString(String),
+ IllegalUtf8String(String),
+ ExpectedWhitespace,
+ // Notes
+ NoteToMatchThis(Token),
+
+ /// Should be an unreachable error
+ UnexpectedParserFailure,
+ /// Should be an unreachable failure which invalidates the transaction
+ InterpreterFailure,
+
+ ExecutionTimeExpired,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct ParseError {
+ pub err: ParseErrors,
+ pub pre_expressions: Option>,
+ pub diagnostic: Diagnostic,
+}
+
+impl ParseError {
+ pub fn new(err: ParseErrors) -> ParseError {
+ let diagnostic = Diagnostic::err(&err);
+ ParseError {
+ err,
+ pre_expressions: None,
+ diagnostic,
+ }
+ }
+
+ pub fn rejectable(&self) -> bool {
+ matches!(self.err, ParseErrors::InterpreterFailure)
+ }
+
+ pub fn has_pre_expression(&self) -> bool {
+ self.pre_expressions.is_some()
+ }
+
+ pub fn set_pre_expression(&mut self, expr: &PreSymbolicExpression) {
+ self.diagnostic.spans = vec![expr.span().clone()];
+ self.pre_expressions.replace(vec![expr.clone()]);
+ }
+
+ pub fn set_pre_expressions(&mut self, exprs: Vec) {
+ self.diagnostic.spans = exprs.iter().map(|e| e.span().clone()).collect();
+ self.pre_expressions.replace(exprs.to_vec());
+ }
+}
+
+impl fmt::Display for ParseError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{:?}", self.err)?;
+
+ if let Some(ref e) = self.pre_expressions {
+ write!(f, "\nNear:\n{e:?}")?;
+ }
+
+ Ok(())
+ }
+}
+
+impl error::Error for ParseError {
+ fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+ None
+ }
+}
+
+impl From for ParseError {
+ fn from(err: ParseErrors) -> Self {
+ ParseError::new(err)
+ }
+}
+
+impl From for ParseError {
+ fn from(err: CostErrors) -> Self {
+ match err {
+ CostErrors::CostOverflow => ParseError::new(ParseErrors::CostOverflow),
+ CostErrors::CostBalanceExceeded(a, b) => {
+ ParseError::new(ParseErrors::CostBalanceExceeded(a, b))
+ }
+ CostErrors::MemoryBalanceExceeded(a, b) => {
+ ParseError::new(ParseErrors::MemoryBalanceExceeded(a, b))
+ }
+ CostErrors::CostComputationFailed(s) => {
+ ParseError::new(ParseErrors::CostComputationFailed(s))
+ }
+ CostErrors::CostContractLoadFailure => ParseError::new(
+ ParseErrors::CostComputationFailed("Failed to load cost contract".into()),
+ ),
+ CostErrors::InterpreterFailure | CostErrors::Expect(_) => {
+ ParseError::new(ParseErrors::InterpreterFailure)
+ }
+ CostErrors::ExecutionTimeExpired => ParseError::new(ParseErrors::ExecutionTimeExpired),
+ }
+ }
+}
+
+impl DiagnosableError for ParseErrors {
+ fn message(&self) -> String {
+ match &self {
+ ParseErrors::CostOverflow => "Used up cost budget during the parse".into(),
+ ParseErrors::CostBalanceExceeded(bal, used) => {
+ format!("Used up cost budget during the parse: {bal} balance, {used} used")
+ }
+ ParseErrors::MemoryBalanceExceeded(bal, used) => {
+ format!("Used up memory budget during the parse: {bal} balance, {used} used")
+ }
+ ParseErrors::TooManyExpressions => "Too many expressions".into(),
+ ParseErrors::FailedCapturingInput => "Failed to capture value from input".into(),
+ ParseErrors::SeparatorExpected(found) => {
+ format!("Expected whitespace or a close parens. Found: '{found}'")
+ }
+ ParseErrors::SeparatorExpectedAfterColon(found) => {
+ format!("Whitespace expected after colon (:), Found: '{found}'")
+ }
+ ParseErrors::ProgramTooLarge => "Program too large to parse".into(),
+ ParseErrors::IllegalContractName(contract_name) => {
+ format!("Illegal contract name: '{contract_name}'")
+ }
+ ParseErrors::IllegalVariableName(var_name) => {
+ format!("Illegal variable name: '{var_name}'")
+ }
+ ParseErrors::UnknownQuotedValue(value) => format!("Unknown 'quoted value '{value}'"),
+ ParseErrors::FailedParsingIntValue(value) => {
+ format!("Failed to parse int literal '{value}'")
+ }
+ ParseErrors::FailedParsingUIntValue(value) => {
+ format!("Failed to parse uint literal 'u{value}'")
+ }
+ ParseErrors::FailedParsingHexValue(value, x) => {
+ format!("Invalid hex-string literal {value}: {x}")
+ }
+ ParseErrors::FailedParsingPrincipal(value) => {
+ format!("Invalid principal literal: {value}")
+ }
+ ParseErrors::FailedParsingBuffer(value) => format!("Invalid buffer literal: {value}"),
+ ParseErrors::FailedParsingField(value) => format!("Invalid field literal: {value}"),
+ ParseErrors::FailedParsingRemainder(remainder) => {
+ format!("Failed to lex input remainder: '{remainder}'")
+ }
+ ParseErrors::ClosingParenthesisUnexpected => {
+ "Tried to close list which isn't open.".into()
+ }
+ ParseErrors::ClosingParenthesisExpected => "List expressions (..) left opened.".into(),
+ ParseErrors::ClosingTupleLiteralUnexpected => {
+ "Tried to close tuple literal which isn't open.".into()
+ }
+ ParseErrors::ClosingTupleLiteralExpected => "Tuple literal {{..}} left opened.".into(),
+ ParseErrors::ColonSeparatorUnexpected => "Misplaced colon.".into(),
+ ParseErrors::CommaSeparatorUnexpected => "Misplaced comma.".into(),
+ ParseErrors::TupleColonExpected(i) => {
+ format!("Tuple literal construction expects a colon at index {i}")
+ }
+ ParseErrors::TupleCommaExpected(i) => {
+ format!("Tuple literal construction expects a comma at index {i}")
+ }
+ ParseErrors::TupleItemExpected(i) => {
+ format!("Tuple literal construction expects a key or value at index {i}")
+ }
+ ParseErrors::CircularReference(function_names) => format!(
+ "detected interdependent functions ({})",
+ function_names.join(", ")
+ ),
+ ParseErrors::NameAlreadyUsed(name) => {
+ format!("defining '{name}' conflicts with previous value")
+ }
+ ParseErrors::ImportTraitBadSignature => {
+ "(use-trait ...) expects a trait name and a trait identifier".into()
+ }
+ ParseErrors::DefineTraitBadSignature => {
+ "(define-trait ...) expects a trait name and a trait definition".into()
+ }
+ ParseErrors::ImplTraitBadSignature => {
+ "(impl-trait ...) expects a trait identifier".into()
+ }
+ ParseErrors::TraitReferenceNotAllowed => "trait references can not be stored".into(),
+ ParseErrors::TraitReferenceUnknown(trait_name) => {
+ format!("use of undeclared trait <{trait_name}>")
+ }
+ ParseErrors::ExpressionStackDepthTooDeep => format!(
+ "AST has too deep of an expression nesting. The maximum stack depth is {MAX_CALL_STACK_DEPTH}"
+ ),
+ ParseErrors::VaryExpressionStackDepthTooDeep => format!(
+ "AST has too deep of an expression nesting. The maximum stack depth is {MAX_CALL_STACK_DEPTH}"
+ ),
+ ParseErrors::InvalidCharactersDetected => "invalid characters detected".into(),
+ ParseErrors::InvalidEscaping => "invalid escaping detected in string".into(),
+ ParseErrors::CostComputationFailed(s) => format!("Cost computation failed: {s}"),
+
+ // Parser v2 errors
+ ParseErrors::Lexer(le) => le.message(),
+ ParseErrors::ContractNameTooLong(name) => {
+ format!("contract name '{name}' is too long")
+ }
+ ParseErrors::ExpectedContractIdentifier => "expected contract identifier".into(),
+ ParseErrors::ExpectedTraitIdentifier => "expected trait identifier".into(),
+ ParseErrors::IllegalTraitName(name) => format!("illegal trait name, '{name}'"),
+ ParseErrors::InvalidPrincipalLiteral => "invalid principal literal".into(),
+ ParseErrors::InvalidBuffer => "invalid hex-string literal".into(),
+ ParseErrors::NameTooLong(name) => format!("illegal name (too long), '{name}'"),
+ ParseErrors::UnexpectedToken(token) => format!("unexpected '{token}'"),
+ ParseErrors::ExpectedClosing(token) => format!("expected closing '{token}'"),
+ ParseErrors::TupleColonExpectedv2 => "expected ':' after key in tuple".into(),
+ ParseErrors::TupleCommaExpectedv2 => {
+ "expected ',' separating key-value pairs in tuple".into()
+ }
+ ParseErrors::TupleValueExpected => "expected value expression for tuple".into(),
+ ParseErrors::IllegalClarityName(name) => format!("illegal clarity name, '{name}'"),
+ ParseErrors::IllegalASCIIString(s) => format!("illegal ascii string \"{s}\""),
+ ParseErrors::IllegalUtf8String(s) => format!("illegal UTF8 string \"{s}\""),
+ ParseErrors::ExpectedWhitespace => "expected whitespace before expression".into(),
+ ParseErrors::NoteToMatchThis(token) => format!("to match this '{token}'"),
+ ParseErrors::UnexpectedParserFailure => "unexpected failure while parsing".to_string(),
+ ParseErrors::InterpreterFailure => "unexpected failure while parsing".to_string(),
+ ParseErrors::ExecutionTimeExpired => "max execution time expired".to_string(),
+ }
+ }
+
+ fn suggestion(&self) -> Option {
+ None
+ }
+
+ fn level(&self) -> Level {
+ match self {
+ ParseErrors::NoteToMatchThis(_) => Level::Note,
+ ParseErrors::Lexer(lexer_error) => lexer_error.level(),
+ _ => Level::Error,
+ }
+ }
+}
+
+pub struct PlacedError {
+ pub e: ParseErrors,
+ pub span: Span,
+}
diff --git a/clarity-serialization/src/errors/cost.rs b/clarity-serialization/src/errors/cost.rs
new file mode 100644
index 0000000000..2678d8ade4
--- /dev/null
+++ b/clarity-serialization/src/errors/cost.rs
@@ -0,0 +1,54 @@
+// 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 .
+use std::fmt;
+
+use crate::execution_cost::ExecutionCost;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum CostErrors {
+ CostComputationFailed(String),
+ CostOverflow,
+ CostBalanceExceeded(ExecutionCost, ExecutionCost),
+ MemoryBalanceExceeded(u64, u64),
+ CostContractLoadFailure,
+ InterpreterFailure,
+ Expect(String),
+ ExecutionTimeExpired,
+}
+
+impl fmt::Display for CostErrors {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ CostErrors::CostComputationFailed(s) => write!(f, "Cost computation failed: {s}"),
+ CostErrors::CostOverflow => write!(f, "Cost overflow"),
+ CostErrors::CostBalanceExceeded(total, limit) => {
+ write!(f, "Cost balance exceeded: total {total}, limit {limit}")
+ }
+ CostErrors::MemoryBalanceExceeded(used, limit) => {
+ write!(f, "Memory balance exceeded: used {used}, limit {limit}")
+ }
+ CostErrors::CostContractLoadFailure => write!(f, "Failed to load cost contract"),
+ CostErrors::InterpreterFailure => write!(f, "Interpreter failure"),
+ CostErrors::Expect(s) => write!(f, "Expectation failed: {s}"),
+ CostErrors::ExecutionTimeExpired => write!(f, "Execution time expired"),
+ }
+ }
+}
+
+impl CostErrors {
+ pub fn rejectable(&self) -> bool {
+ matches!(self, CostErrors::InterpreterFailure | CostErrors::Expect(_))
+ }
+}
diff --git a/clarity-serialization/src/errors/lexer.rs b/clarity-serialization/src/errors/lexer.rs
new file mode 100644
index 0000000000..27d6a2c3a2
--- /dev/null
+++ b/clarity-serialization/src/errors/lexer.rs
@@ -0,0 +1,94 @@
+// 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 .
+
+use crate::diagnostic::{DiagnosableError, Level};
+use crate::representations::Span;
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum LexerError {
+ InvalidCharInt(char),
+ InvalidCharUint(char),
+ InvalidCharBuffer(char),
+ InvalidCharIdent(char),
+ InvalidCharTraitIdent(char),
+ InvalidCharPrincipal(char),
+ InvalidBufferLength(usize),
+ UnknownEscapeChar(char),
+ IllegalCharString(char),
+ IllegalCharUTF8Encoding(char),
+ UnterminatedUTF8Encoding,
+ ExpectedClosing(char),
+ ExpectedSeparator,
+ EmptyUTF8Encoding,
+ InvalidUTF8Encoding,
+ SingleSemiColon,
+ UnknownSymbol(char),
+ NonASCIIChar(char),
+ NoteToMatchThis(char),
+ UnsupportedLineEnding,
+ EditorCRLFMode,
+}
+
+#[derive(Debug)]
+pub struct PlacedError {
+ pub e: LexerError,
+ pub span: Span,
+}
+
+impl DiagnosableError for LexerError {
+ fn message(&self) -> String {
+ use self::LexerError::*;
+ match self {
+ InvalidCharInt(c) => format!("invalid character, '{c}', in int literal"),
+ InvalidCharUint(c) => format!("invalid character, '{c}', in uint literal"),
+ InvalidCharBuffer(c) => format!("invalid character, '{c}', in buffer"),
+ InvalidCharIdent(c) => format!("invalid character, '{c}', in identifier"),
+ InvalidCharTraitIdent(c) => format!("invalid character, '{c}', in trait identifier"),
+ InvalidCharPrincipal(c) => format!("invalid character, '{c}', in principal literal"),
+ IllegalCharString(c) => format!("invalid character, '{c}', in string literal"),
+ IllegalCharUTF8Encoding(c) => format!("invalid character, '{c}', in UTF8 encoding"),
+ InvalidUTF8Encoding => "invalid UTF8 encoding".to_string(),
+ EmptyUTF8Encoding => "empty UTF8 encoding".to_string(),
+ UnterminatedUTF8Encoding => "unterminated UTF8 encoding, missing '}'".to_string(),
+ InvalidBufferLength(size) => format!("invalid buffer length, {size}"),
+ UnknownEscapeChar(c) => format!("unknown escape character, '{c}'"),
+ ExpectedClosing(c) => format!("expected closing '{c}'"),
+ ExpectedSeparator => "expected separator".to_string(),
+ SingleSemiColon => "unexpected single ';' (comments begin with \";;\"".to_string(),
+ UnknownSymbol(c) => format!("unknown symbol, '{c}'"),
+ NonASCIIChar(c) => format!("illegal non-ASCII character, '{c}'"),
+ NoteToMatchThis(c) => format!("to match this '{c}'"),
+ UnsupportedLineEnding => {
+ "unsupported line-ending '\\r', only '\\n' is supported".to_string()
+ }
+ EditorCRLFMode => {
+ "you may need to change your editor from CRLF mode to LF mode".to_string()
+ }
+ }
+ }
+
+ fn suggestion(&self) -> Option {
+ None
+ }
+
+ fn level(&self) -> Level {
+ use self::LexerError::*;
+ match self {
+ NoteToMatchThis(_) => Level::Note,
+ EditorCRLFMode => Level::Note,
+ _ => Level::Error,
+ }
+ }
+}
diff --git a/clarity-serialization/src/errors/mod.rs b/clarity-serialization/src/errors/mod.rs
new file mode 100644
index 0000000000..e65fe47e62
--- /dev/null
+++ b/clarity-serialization/src/errors/mod.rs
@@ -0,0 +1,256 @@
+// 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 .
+
+pub mod analysis;
+pub mod ast;
+pub mod cost;
+pub mod lexer;
+
+use std::{error, fmt};
+
+pub use analysis::{CheckError, CheckErrors, CheckResult};
+pub use ast::{ParseError, ParseErrors, ParseResult};
+pub use cost::CostErrors;
+pub use lexer::LexerError;
+#[cfg(feature = "rusqlite")]
+use rusqlite::Error as SqliteError;
+use serde_json::Error as SerdeJSONErr;
+use stacks_common::types::chainstate::BlockHeaderHash;
+
+use crate::types::{FunctionIdentifier, Value};
+
+pub type StackTrace = Vec;
+
+#[derive(Debug)]
+pub struct IncomparableError {
+ pub err: T,
+}
+
+#[derive(Debug)]
+pub enum Error {
+ /// UncheckedErrors are errors that *should* be caught by the
+ /// TypeChecker and other check passes. Test executions may
+ /// trigger these errors.
+ Unchecked(CheckErrors),
+ Interpreter(InterpreterError),
+ Runtime(RuntimeErrorType, Option),
+ ShortReturn(ShortReturnType),
+}
+
+/// InterpreterErrors are errors that *should never* occur.
+/// Test executions may trigger these errors.
+#[derive(Debug, PartialEq)]
+pub enum InterpreterError {
+ BadSender(Value),
+ BadSymbolicRepresentation(String),
+ InterpreterError(String),
+ UninitializedPersistedVariable,
+ FailedToConstructAssetTable,
+ FailedToConstructEventBatch,
+ #[cfg(feature = "rusqlite")]
+ SqliteError(IncomparableError),
+ BadFileName,
+ FailedToCreateDataDirectory,
+ MarfFailure(String),
+ FailureConstructingTupleWithType,
+ FailureConstructingListWithType,
+ InsufficientBalance,
+ CostContractLoadFailure,
+ DBError(String),
+ Expect(String),
+}
+
+/// RuntimeErrors are errors that smart contracts are expected
+/// to be able to trigger during execution (e.g., arithmetic errors)
+#[derive(Debug, PartialEq)]
+pub enum RuntimeErrorType {
+ Arithmetic(String),
+ ArithmeticOverflow,
+ ArithmeticUnderflow,
+ SupplyOverflow(u128, u128),
+ SupplyUnderflow(u128, u128),
+ DivisionByZero,
+ // error in parsing types
+ ParseError(String),
+ // error in parsing the AST
+ ASTError(ParseError),
+ MaxStackDepthReached,
+ MaxContextDepthReached,
+ ListDimensionTooHigh,
+ BadTypeConstruction,
+ ValueTooLarge,
+ BadBlockHeight(String),
+ TransferNonPositiveAmount,
+ NoSuchToken,
+ NotImplemented,
+ NoCallerInContext,
+ NoSenderInContext,
+ NonPositiveTokenSupply,
+ JSONParseError(IncomparableError),
+ AttemptToFetchInTransientContext,
+ BadNameValue(&'static str, String),
+ UnknownBlockHeaderHash(BlockHeaderHash),
+ BadBlockHash(Vec),
+ UnwrapFailure,
+ DefunctPoxContract,
+ PoxAlreadyLocked,
+ MetadataAlreadySet,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum ShortReturnType {
+ ExpectedValue(Value),
+ AssertionFailed(Value),
+}
+
+pub type InterpreterResult = Result;
+
+impl PartialEq> for IncomparableError {
+ fn eq(&self, _other: &IncomparableError) -> bool {
+ false
+ }
+}
+
+impl PartialEq for Error {
+ fn eq(&self, other: &Error) -> bool {
+ match (self, other) {
+ (Error::Runtime(x, _), Error::Runtime(y, _)) => x == y,
+ (Error::Unchecked(x), Error::Unchecked(y)) => x == y,
+ (Error::ShortReturn(x), Error::ShortReturn(y)) => x == y,
+ (Error::Interpreter(x), Error::Interpreter(y)) => x == y,
+ _ => false,
+ }
+ }
+}
+
+impl fmt::Display for Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ Error::Runtime(err, stack) => {
+ write!(f, "{err}")?;
+ if let Some(stack_trace) = stack {
+ writeln!(f, "\n Stack Trace: ")?;
+ for item in stack_trace.iter() {
+ writeln!(f, "{item}")?;
+ }
+ }
+ Ok(())
+ }
+ _ => write!(f, "{self:?}"),
+ }
+ }
+}
+
+impl fmt::Display for RuntimeErrorType {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "{self:?}")
+ }
+}
+
+impl error::Error for Error {
+ fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+ None
+ }
+}
+
+impl error::Error for RuntimeErrorType {
+ fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+ None
+ }
+}
+
+impl From for Error {
+ fn from(err: ParseError) -> Self {
+ match &err.err {
+ ParseErrors::InterpreterFailure => Error::from(InterpreterError::Expect(
+ "Unexpected interpreter failure during parsing".into(),
+ )),
+ _ => Error::from(RuntimeErrorType::ASTError(err)),
+ }
+ }
+}
+
+impl From for Error {
+ fn from(err: CostErrors) -> Self {
+ match err {
+ CostErrors::InterpreterFailure => Error::from(InterpreterError::Expect(
+ "Interpreter failure during cost calculation".into(),
+ )),
+ CostErrors::Expect(s) => Error::from(InterpreterError::Expect(format!(
+ "Interpreter failure during cost calculation: {s}"
+ ))),
+ other_err => Error::from(CheckErrors::from(other_err)),
+ }
+ }
+}
+
+impl From for Error {
+ fn from(err: RuntimeErrorType) -> Self {
+ Error::Runtime(err, None)
+ }
+}
+
+impl From for Error {
+ fn from(err: CheckErrors) -> Self {
+ Error::Unchecked(err)
+ }
+}
+
+impl From for Error {
+ fn from(err: ShortReturnType) -> Self {
+ Error::ShortReturn(err)
+ }
+}
+
+impl From for Error {
+ fn from(err: InterpreterError) -> Self {
+ Error::Interpreter(err)
+ }
+}
+
+#[cfg(any(test, feature = "testing"))]
+impl From for () {
+ fn from(_err: Error) -> Self {}
+}
+
+impl From for Value {
+ fn from(val: ShortReturnType) -> Self {
+ match val {
+ ShortReturnType::ExpectedValue(v) => v,
+ ShortReturnType::AssertionFailed(v) => v,
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn equality() {
+ assert_eq!(
+ Error::ShortReturn(ShortReturnType::ExpectedValue(Value::Bool(true))),
+ Error::ShortReturn(ShortReturnType::ExpectedValue(Value::Bool(true)))
+ );
+ assert_eq!(
+ Error::Interpreter(InterpreterError::InterpreterError("".to_string())),
+ Error::Interpreter(InterpreterError::InterpreterError("".to_string()))
+ );
+ assert!(
+ Error::ShortReturn(ShortReturnType::ExpectedValue(Value::Bool(true)))
+ != Error::Interpreter(InterpreterError::InterpreterError("".to_string()))
+ );
+ }
+}
diff --git a/clarity-serialization/src/execution_cost.rs b/clarity-serialization/src/execution_cost.rs
new file mode 100644
index 0000000000..d261eb00c1
--- /dev/null
+++ b/clarity-serialization/src/execution_cost.rs
@@ -0,0 +1,217 @@
+// 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 .
+use std::{cmp, fmt};
+
+#[cfg(feature = "rusqlite")]
+use rusqlite::{
+ ToSql,
+ types::{FromSql, FromSqlResult, ToSqlOutput, ValueRef},
+};
+
+use crate::errors::CostErrors;
+
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq, Hash)]
+pub struct ExecutionCost {
+ pub write_length: u64,
+ pub write_count: u64,
+ pub read_length: u64,
+ pub read_count: u64,
+ pub runtime: u64,
+}
+
+impl fmt::Display for ExecutionCost {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(
+ f,
+ "{{\"runtime\": {}, \"write_len\": {}, \"write_cnt\": {}, \"read_len\": {}, \"read_cnt\": {}}}",
+ self.runtime, self.write_length, self.write_count, self.read_length, self.read_count
+ )
+ }
+}
+
+impl ExecutionCost {
+ pub const ZERO: Self = Self {
+ runtime: 0,
+ write_length: 0,
+ read_count: 0,
+ write_count: 0,
+ read_length: 0,
+ };
+
+ /// Returns the percentage of self consumed in `numerator`'s largest proportion dimension.
+ pub fn proportion_largest_dimension(&self, numerator: &ExecutionCost) -> u64 {
+ // max() should always return because there are > 0 elements
+ #[allow(clippy::expect_used)]
+ *[
+ numerator.runtime / cmp::max(1, self.runtime / 100),
+ numerator.write_length / cmp::max(1, self.write_length / 100),
+ numerator.write_count / cmp::max(1, self.write_count / 100),
+ numerator.read_length / cmp::max(1, self.read_length / 100),
+ numerator.read_count / cmp::max(1, self.read_count / 100),
+ ]
+ .iter()
+ .max()
+ .expect("BUG: should find maximum")
+ }
+
+ /// Returns the dot product of this execution cost with `resolution`/block_limit
+ /// This provides a scalar value representing the cumulative consumption
+ /// of `self` in the provided block_limit.
+ pub fn proportion_dot_product(&self, block_limit: &ExecutionCost, resolution: u64) -> u64 {
+ [
+ // each field here is calculating `r * self / limit`, using f64
+ // use MAX(1, block_limit) to guard against divide by zero
+ // use MIN(1, self/block_limit) to guard against self > block_limit
+ resolution as f64
+ * 1_f64.min(self.runtime as f64 / 1_f64.max(block_limit.runtime as f64)),
+ resolution as f64
+ * 1_f64.min(self.read_count as f64 / 1_f64.max(block_limit.read_count as f64)),
+ resolution as f64
+ * 1_f64.min(self.write_count as f64 / 1_f64.max(block_limit.write_count as f64)),
+ resolution as f64
+ * 1_f64.min(self.read_length as f64 / 1_f64.max(block_limit.read_length as f64)),
+ resolution as f64
+ * 1_f64.min(self.write_length as f64 / 1_f64.max(block_limit.write_length as f64)),
+ ]
+ .iter()
+ .fold(0, |acc, dim| acc.saturating_add(cmp::max(*dim as u64, 1)))
+ }
+
+ pub fn max_value() -> ExecutionCost {
+ Self {
+ runtime: u64::MAX,
+ write_length: u64::MAX,
+ read_count: u64::MAX,
+ write_count: u64::MAX,
+ read_length: u64::MAX,
+ }
+ }
+
+ pub fn runtime(runtime: u64) -> ExecutionCost {
+ Self {
+ runtime,
+ write_length: 0,
+ read_count: 0,
+ write_count: 0,
+ read_length: 0,
+ }
+ }
+
+ pub fn add_runtime(&mut self, runtime: u64) -> Result<(), CostErrors> {
+ self.runtime = self.runtime.cost_overflow_add(runtime)?;
+ Ok(())
+ }
+
+ pub fn add(&mut self, other: &ExecutionCost) -> Result<(), CostErrors> {
+ self.runtime = self.runtime.cost_overflow_add(other.runtime)?;
+ self.read_count = self.read_count.cost_overflow_add(other.read_count)?;
+ self.read_length = self.read_length.cost_overflow_add(other.read_length)?;
+ self.write_length = self.write_length.cost_overflow_add(other.write_length)?;
+ self.write_count = self.write_count.cost_overflow_add(other.write_count)?;
+ Ok(())
+ }
+
+ pub fn sub(&mut self, other: &ExecutionCost) -> Result<(), CostErrors> {
+ self.runtime = self.runtime.cost_overflow_sub(other.runtime)?;
+ self.read_count = self.read_count.cost_overflow_sub(other.read_count)?;
+ self.read_length = self.read_length.cost_overflow_sub(other.read_length)?;
+ self.write_length = self.write_length.cost_overflow_sub(other.write_length)?;
+ self.write_count = self.write_count.cost_overflow_sub(other.write_count)?;
+ Ok(())
+ }
+
+ pub fn multiply(&mut self, times: u64) -> Result<(), CostErrors> {
+ self.runtime = self.runtime.cost_overflow_mul(times)?;
+ self.read_count = self.read_count.cost_overflow_mul(times)?;
+ self.read_length = self.read_length.cost_overflow_mul(times)?;
+ self.write_length = self.write_length.cost_overflow_mul(times)?;
+ self.write_count = self.write_count.cost_overflow_mul(times)?;
+ Ok(())
+ }
+
+ pub fn divide(&mut self, divisor: u64) -> Result<(), CostErrors> {
+ self.runtime = self.runtime.cost_overflow_div(divisor)?;
+ self.read_count = self.read_count.cost_overflow_div(divisor)?;
+ self.read_length = self.read_length.cost_overflow_div(divisor)?;
+ self.write_length = self.write_length.cost_overflow_div(divisor)?;
+ self.write_count = self.write_count.cost_overflow_div(divisor)?;
+ Ok(())
+ }
+
+ /// Returns whether or not this cost exceeds any dimension of the
+ /// other cost.
+ pub fn exceeds(&self, other: &ExecutionCost) -> bool {
+ self.runtime > other.runtime
+ || self.write_length > other.write_length
+ || self.write_count > other.write_count
+ || self.read_count > other.read_count
+ || self.read_length > other.read_length
+ }
+
+ pub fn max_cost(first: ExecutionCost, second: ExecutionCost) -> ExecutionCost {
+ Self {
+ runtime: first.runtime.max(second.runtime),
+ write_length: first.write_length.max(second.write_length),
+ write_count: first.write_count.max(second.write_count),
+ read_count: first.read_count.max(second.read_count),
+ read_length: first.read_length.max(second.read_length),
+ }
+ }
+
+ pub fn is_zero(&self) -> bool {
+ *self == Self::ZERO
+ }
+}
+
+pub trait CostOverflowingMath {
+ fn cost_overflow_mul(self, other: T) -> Result;
+ fn cost_overflow_add(self, other: T) -> Result;
+ fn cost_overflow_sub(self, other: T) -> Result;
+ fn cost_overflow_div(self, other: T) -> Result;
+}
+
+impl CostOverflowingMath for u64 {
+ fn cost_overflow_mul(self, other: u64) -> Result {
+ self.checked_mul(other).ok_or(CostErrors::CostOverflow)
+ }
+ fn cost_overflow_add(self, other: u64) -> Result {
+ self.checked_add(other).ok_or(CostErrors::CostOverflow)
+ }
+ fn cost_overflow_sub(self, other: u64) -> Result {
+ self.checked_sub(other).ok_or(CostErrors::CostOverflow)
+ }
+ fn cost_overflow_div(self, other: u64) -> Result {
+ self.checked_div(other).ok_or(CostErrors::CostOverflow)
+ }
+}
+
+#[cfg(feature = "rusqlite")]
+impl ToSql for ExecutionCost {
+ fn to_sql(&self) -> rusqlite::Result> {
+ let val = serde_json::to_string(self)
+ .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+ Ok(ToSqlOutput::from(val))
+ }
+}
+
+#[cfg(feature = "rusqlite")]
+impl FromSql for ExecutionCost {
+ fn column_result(value: ValueRef) -> FromSqlResult {
+ let str_val = String::column_result(value)?;
+ let parsed = serde_json::from_str(&str_val)
+ .map_err(|e| rusqlite::types::FromSqlError::Other(Box::new(e)))?;
+ Ok(parsed)
+ }
+}
diff --git a/clarity-serialization/src/lib.rs b/clarity-serialization/src/lib.rs
index 054d8d0a1b..de51f53915 100644
--- a/clarity-serialization/src/lib.rs
+++ b/clarity-serialization/src/lib.rs
@@ -24,14 +24,19 @@ pub use stacks_common::{
impl_byte_array_serde, types as stacks_types, util,
};
+pub mod diagnostic;
pub mod errors;
+pub mod execution_cost;
pub mod representations;
+pub mod token;
pub mod types;
-pub use errors::CodecError;
+pub use errors::Error;
pub use representations::{ClarityName, ContractName};
pub use types::Value;
+pub const MAX_CALL_STACK_DEPTH: usize = 64;
+
#[cfg(test)]
pub mod tests;
diff --git a/clarity-serialization/src/representations.rs b/clarity-serialization/src/representations.rs
index 74bffc2a53..f68d35ee2e 100644
--- a/clarity-serialization/src/representations.rs
+++ b/clarity-serialization/src/representations.rs
@@ -22,7 +22,9 @@ use lazy_static::lazy_static;
use regex::Regex;
use stacks_common::codec::{Error as codec_error, StacksMessageCodec, read_next, write_next};
-use crate::errors::CodecError;
+use crate::Value;
+use crate::errors::RuntimeErrorType;
+use crate::types::TraitIdentifier;
pub const CONTRACT_MIN_NAME_LENGTH: usize = 1;
pub const CONTRACT_MAX_NAME_LENGTH: usize = 40;
@@ -64,8 +66,8 @@ guarded_string!(
"ClarityName",
CLARITY_NAME_REGEX,
MAX_STRING_LEN,
- CodecError,
- CodecError::InvalidClarityName
+ RuntimeErrorType,
+ RuntimeErrorType::BadNameValue
);
guarded_string!(
@@ -73,8 +75,8 @@ guarded_string!(
"ContractName",
CONTRACT_NAME_REGEX,
MAX_STRING_LEN,
- CodecError,
- CodecError::InvalidContractName
+ RuntimeErrorType,
+ RuntimeErrorType::BadNameValue
);
impl StacksMessageCodec for ClarityName {
@@ -160,3 +162,513 @@ impl StacksMessageCodec for ContractName {
Ok(name)
}
}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub enum PreSymbolicExpressionType {
+ AtomValue(Value),
+ Atom(ClarityName),
+ List(Vec),
+ Tuple(Vec),
+ SugaredContractIdentifier(ContractName),
+ SugaredFieldIdentifier(ContractName, ClarityName),
+ FieldIdentifier(TraitIdentifier),
+ TraitReference(ClarityName),
+ Comment(String),
+ Placeholder(String),
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub struct PreSymbolicExpression {
+ pub pre_expr: PreSymbolicExpressionType,
+ pub id: u64,
+
+ #[cfg(feature = "developer-mode")]
+ pub span: Span,
+}
+
+pub trait SymbolicExpressionCommon {
+ type S: SymbolicExpressionCommon;
+ fn set_id(&mut self, id: u64);
+ fn match_list_mut(&mut self) -> Option<&mut [Self::S]>;
+}
+
+impl SymbolicExpressionCommon for PreSymbolicExpression {
+ type S = PreSymbolicExpression;
+ fn set_id(&mut self, id: u64) {
+ self.id = id;
+ }
+ fn match_list_mut(&mut self) -> Option<&mut [PreSymbolicExpression]> {
+ if let PreSymbolicExpressionType::List(ref mut list) = self.pre_expr {
+ Some(list)
+ } else {
+ None
+ }
+ }
+}
+
+impl SymbolicExpressionCommon for SymbolicExpression {
+ type S = SymbolicExpression;
+ fn set_id(&mut self, id: u64) {
+ self.id = id;
+ }
+ fn match_list_mut(&mut self) -> Option<&mut [SymbolicExpression]> {
+ if let SymbolicExpressionType::List(ref mut list) = self.expr {
+ Some(list)
+ } else {
+ None
+ }
+ }
+}
+
+impl PreSymbolicExpression {
+ #[cfg(feature = "developer-mode")]
+ fn cons() -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ id: 0,
+ span: Span::zero(),
+ pre_expr: PreSymbolicExpressionType::AtomValue(Value::Bool(false)),
+ }
+ }
+ #[cfg(not(feature = "developer-mode"))]
+ fn cons() -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ id: 0,
+ pre_expr: PreSymbolicExpressionType::AtomValue(Value::Bool(false)),
+ }
+ }
+
+ #[cfg(feature = "developer-mode")]
+ pub fn set_span(&mut self, start_line: u32, start_column: u32, end_line: u32, end_column: u32) {
+ self.span = Span {
+ start_line,
+ start_column,
+ end_line,
+ end_column,
+ }
+ }
+
+ #[cfg(not(feature = "developer-mode"))]
+ pub fn set_span(
+ &mut self,
+ _start_line: u32,
+ _start_column: u32,
+ _end_line: u32,
+ _end_column: u32,
+ ) {
+ }
+
+ #[cfg(feature = "developer-mode")]
+ pub fn copy_span(&mut self, src: &Span) {
+ self.span = src.clone();
+ }
+
+ #[cfg(not(feature = "developer-mode"))]
+ pub fn copy_span(&mut self, _src: &Span) {}
+
+ #[cfg(feature = "developer-mode")]
+ pub fn span(&self) -> &Span {
+ &self.span
+ }
+
+ #[cfg(not(feature = "developer-mode"))]
+ pub fn span(&self) -> &Span {
+ &Span::ZERO
+ }
+
+ pub fn sugared_contract_identifier(val: ContractName) -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ pre_expr: PreSymbolicExpressionType::SugaredContractIdentifier(val),
+ ..PreSymbolicExpression::cons()
+ }
+ }
+
+ pub fn sugared_field_identifier(
+ contract_name: ContractName,
+ name: ClarityName,
+ ) -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ pre_expr: PreSymbolicExpressionType::SugaredFieldIdentifier(contract_name, name),
+ ..PreSymbolicExpression::cons()
+ }
+ }
+
+ pub fn atom_value(val: Value) -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ pre_expr: PreSymbolicExpressionType::AtomValue(val),
+ ..PreSymbolicExpression::cons()
+ }
+ }
+
+ pub fn atom(val: ClarityName) -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ pre_expr: PreSymbolicExpressionType::Atom(val),
+ ..PreSymbolicExpression::cons()
+ }
+ }
+
+ pub fn trait_reference(val: ClarityName) -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ pre_expr: PreSymbolicExpressionType::TraitReference(val),
+ ..PreSymbolicExpression::cons()
+ }
+ }
+
+ pub fn field_identifier(val: TraitIdentifier) -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ pre_expr: PreSymbolicExpressionType::FieldIdentifier(val),
+ ..PreSymbolicExpression::cons()
+ }
+ }
+
+ pub fn list(val: Vec) -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ pre_expr: PreSymbolicExpressionType::List(val),
+ ..PreSymbolicExpression::cons()
+ }
+ }
+
+ pub fn tuple(val: Vec) -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ pre_expr: PreSymbolicExpressionType::Tuple(val),
+ ..PreSymbolicExpression::cons()
+ }
+ }
+
+ pub fn placeholder(s: String) -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ pre_expr: PreSymbolicExpressionType::Placeholder(s),
+ ..PreSymbolicExpression::cons()
+ }
+ }
+
+ pub fn comment(comment: String) -> PreSymbolicExpression {
+ PreSymbolicExpression {
+ pre_expr: PreSymbolicExpressionType::Comment(comment),
+ ..PreSymbolicExpression::cons()
+ }
+ }
+
+ pub fn match_trait_reference(&self) -> Option<&ClarityName> {
+ if let PreSymbolicExpressionType::TraitReference(ref value) = self.pre_expr {
+ Some(value)
+ } else {
+ None
+ }
+ }
+
+ pub fn match_atom_value(&self) -> Option<&Value> {
+ if let PreSymbolicExpressionType::AtomValue(ref value) = self.pre_expr {
+ Some(value)
+ } else {
+ None
+ }
+ }
+
+ pub fn match_atom(&self) -> Option<&ClarityName> {
+ if let PreSymbolicExpressionType::Atom(ref value) = self.pre_expr {
+ Some(value)
+ } else {
+ None
+ }
+ }
+
+ pub fn match_list(&self) -> Option<&[PreSymbolicExpression]> {
+ if let PreSymbolicExpressionType::List(ref list) = self.pre_expr {
+ Some(list)
+ } else {
+ None
+ }
+ }
+
+ pub fn match_field_identifier(&self) -> Option<&TraitIdentifier> {
+ if let PreSymbolicExpressionType::FieldIdentifier(ref value) = self.pre_expr {
+ Some(value)
+ } else {
+ None
+ }
+ }
+
+ pub fn match_placeholder(&self) -> Option<&str> {
+ if let PreSymbolicExpressionType::Placeholder(ref s) = self.pre_expr {
+ Some(s.as_str())
+ } else {
+ None
+ }
+ }
+
+ pub fn match_comment(&self) -> Option<&str> {
+ if let PreSymbolicExpressionType::Comment(ref s) = self.pre_expr {
+ Some(s.as_str())
+ } else {
+ None
+ }
+ }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub enum SymbolicExpressionType {
+ AtomValue(Value),
+ Atom(ClarityName),
+ List(Vec),
+ LiteralValue(Value),
+ Field(TraitIdentifier),
+ TraitReference(ClarityName, TraitDefinition),
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub enum TraitDefinition {
+ Defined(TraitIdentifier),
+ Imported(TraitIdentifier),
+}
+
+pub fn depth_traverse(expr: &SymbolicExpression, mut visit: F) -> Result, E>
+where
+ F: FnMut(&SymbolicExpression) -> Result,
+{
+ let mut stack = vec![];
+ let mut last = None;
+ stack.push(expr);
+ while let Some(current) = stack.pop() {
+ last = Some(visit(current)?);
+ if let Some(list) = current.match_list() {
+ for item in list.iter() {
+ stack.push(item);
+ }
+ }
+ }
+
+ Ok(last)
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub struct SymbolicExpression {
+ pub expr: SymbolicExpressionType,
+ // this id field is used by compiler passes to store information in
+ // maps.
+ // first pass -> fill out unique ids
+ // ...typing passes -> store information in hashmap according to id.
+ //
+ // this is a fairly standard technique in compiler passes
+ pub id: u64,
+
+ #[cfg(feature = "developer-mode")]
+ #[serde(default)]
+ pub span: Span,
+
+ #[cfg(feature = "developer-mode")]
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub pre_comments: Vec<(String, Span)>,
+ #[cfg(feature = "developer-mode")]
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub end_line_comment: Option,
+ #[cfg(feature = "developer-mode")]
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub post_comments: Vec<(String, Span)>,
+}
+
+impl SymbolicExpression {
+ #[cfg(feature = "developer-mode")]
+ fn cons() -> SymbolicExpression {
+ SymbolicExpression {
+ id: 0,
+ expr: SymbolicExpressionType::AtomValue(Value::Bool(false)),
+ span: Span::zero(),
+ pre_comments: vec![],
+ end_line_comment: None,
+ post_comments: vec![],
+ }
+ }
+ #[cfg(not(feature = "developer-mode"))]
+ fn cons() -> SymbolicExpression {
+ SymbolicExpression {
+ id: 0,
+ expr: SymbolicExpressionType::AtomValue(Value::Bool(false)),
+ }
+ }
+
+ #[cfg(feature = "developer-mode")]
+ pub fn set_span(&mut self, start_line: u32, start_column: u32, end_line: u32, end_column: u32) {
+ self.span = Span {
+ start_line,
+ start_column,
+ end_line,
+ end_column,
+ }
+ }
+
+ #[cfg(not(feature = "developer-mode"))]
+ pub fn set_span(
+ &mut self,
+ _start_line: u32,
+ _start_column: u32,
+ _end_line: u32,
+ _end_column: u32,
+ ) {
+ }
+
+ #[cfg(feature = "developer-mode")]
+ pub fn copy_span(&mut self, src: &Span) {
+ self.span = src.clone();
+ }
+
+ #[cfg(not(feature = "developer-mode"))]
+ pub fn copy_span(&mut self, _src: &Span) {}
+
+ #[cfg(feature = "developer-mode")]
+ pub fn span(&self) -> &Span {
+ &self.span
+ }
+
+ #[cfg(not(feature = "developer-mode"))]
+ pub fn span(&self) -> &Span {
+ &Span::ZERO
+ }
+
+ pub fn atom_value(val: Value) -> SymbolicExpression {
+ SymbolicExpression {
+ expr: SymbolicExpressionType::AtomValue(val),
+ ..SymbolicExpression::cons()
+ }
+ }
+
+ pub fn atom(val: ClarityName) -> SymbolicExpression {
+ SymbolicExpression {
+ expr: SymbolicExpressionType::Atom(val),
+ ..SymbolicExpression::cons()
+ }
+ }
+
+ pub fn literal_value(val: Value) -> SymbolicExpression {
+ SymbolicExpression {
+ expr: SymbolicExpressionType::LiteralValue(val),
+ ..SymbolicExpression::cons()
+ }
+ }
+
+ pub fn list(val: Vec) -> SymbolicExpression {
+ SymbolicExpression {
+ expr: SymbolicExpressionType::List(val),
+ ..SymbolicExpression::cons()
+ }
+ }
+
+ pub fn trait_reference(
+ val: ClarityName,
+ trait_definition: TraitDefinition,
+ ) -> SymbolicExpression {
+ SymbolicExpression {
+ expr: SymbolicExpressionType::TraitReference(val, trait_definition),
+ ..SymbolicExpression::cons()
+ }
+ }
+
+ pub fn field(val: TraitIdentifier) -> SymbolicExpression {
+ SymbolicExpression {
+ expr: SymbolicExpressionType::Field(val),
+ ..SymbolicExpression::cons()
+ }
+ }
+
+ // These match functions are used to simplify calling code
+ // areas a lot. There is a frequent code pattern where
+ // a block _expects_ specific symbolic expressions, leading
+ // to a lot of very verbose `if let x = {` expressions.
+
+ pub fn match_list(&self) -> Option<&[SymbolicExpression]> {
+ if let SymbolicExpressionType::List(ref list) = self.expr {
+ Some(list)
+ } else {
+ None
+ }
+ }
+
+ pub fn match_atom(&self) -> Option<&ClarityName> {
+ if let SymbolicExpressionType::Atom(ref value) = self.expr {
+ Some(value)
+ } else {
+ None
+ }
+ }
+
+ pub fn match_atom_value(&self) -> Option<&Value> {
+ if let SymbolicExpressionType::AtomValue(ref value) = self.expr {
+ Some(value)
+ } else {
+ None
+ }
+ }
+
+ pub fn match_literal_value(&self) -> Option<&Value> {
+ if let SymbolicExpressionType::LiteralValue(ref value) = self.expr {
+ Some(value)
+ } else {
+ None
+ }
+ }
+
+ pub fn match_trait_reference(&self) -> Option<&ClarityName> {
+ if let SymbolicExpressionType::TraitReference(ref value, _) = self.expr {
+ Some(value)
+ } else {
+ None
+ }
+ }
+
+ pub fn match_field(&self) -> Option<&TraitIdentifier> {
+ if let SymbolicExpressionType::Field(ref value) = self.expr {
+ Some(value)
+ } else {
+ None
+ }
+ }
+}
+
+impl fmt::Display for SymbolicExpression {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self.expr {
+ SymbolicExpressionType::List(ref list) => {
+ write!(f, "(")?;
+ for item in list.iter() {
+ write!(f, " {item}")?;
+ }
+ write!(f, " )")?;
+ }
+ SymbolicExpressionType::Atom(ref value) => {
+ write!(f, "{}", &**value)?;
+ }
+ SymbolicExpressionType::AtomValue(ref value)
+ | SymbolicExpressionType::LiteralValue(ref value) => {
+ write!(f, "{value}")?;
+ }
+ SymbolicExpressionType::TraitReference(ref value, _) => {
+ write!(f, "<{}>", &**value)?;
+ }
+ SymbolicExpressionType::Field(ref value) => {
+ write!(f, "<{value}>")?;
+ }
+ };
+
+ Ok(())
+ }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+pub struct Span {
+ pub start_line: u32,
+ pub start_column: u32,
+ pub end_line: u32,
+ pub end_column: u32,
+}
+
+impl Span {
+ pub const ZERO: Span = Span {
+ start_line: 0,
+ start_column: 0,
+ end_line: 0,
+ end_column: 0,
+ };
+
+ pub fn zero() -> Self {
+ Self::default()
+ }
+}
diff --git a/clarity-serialization/src/tests/representations.rs b/clarity-serialization/src/tests/representations.rs
index b4e2219d4f..ac395809c7 100644
--- a/clarity-serialization/src/tests/representations.rs
+++ b/clarity-serialization/src/tests/representations.rs
@@ -15,7 +15,7 @@
use rstest::rstest;
-use crate::errors::CodecError;
+use crate::errors::RuntimeErrorType;
use crate::representations::{
CONTRACT_MAX_NAME_LENGTH, CONTRACT_MIN_NAME_LENGTH, ClarityName, ContractName, MAX_STRING_LEN,
};
@@ -73,7 +73,7 @@ fn test_clarity_name_invalid(#[case] name: &str) {
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
- CodecError::InvalidClarityName(_, _)
+ RuntimeErrorType::BadNameValue(_, _)
));
}
@@ -99,7 +99,7 @@ fn test_clarity_name_serialization(#[case] name: &str) {
// the first byte is the length of the buffer.
#[rstest]
#[case::invalid_utf8(vec![4, 0xFF, 0xFE, 0xFD, 0xFC], "Failed to parse Clarity name: could not contruct from utf8")]
-#[case::invalid_name(vec![2, b'2', b'i'], "Failed to parse Clarity name: InvalidClarityName(\"ClarityName\", \"2i\")")] // starts with number
+#[case::invalid_name(vec![2, b'2', b'i'], "Failed to parse Clarity name: BadNameValue(\"ClarityName\", \"2i\")")] // starts with number
#[case::too_long(vec![MAX_STRING_LEN + 1], "Failed to deserialize clarity name: too long")]
#[case::wrong_length(vec![3, b'a'], "failed to fill whole buffer")]
fn test_clarity_name_deserialization_errors(#[case] buffer: Vec, #[case] error_message: &str) {
@@ -157,7 +157,7 @@ fn test_contract_name_invalid(#[case] name: &str) {
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
- CodecError::InvalidContractName(_, _)
+ RuntimeErrorType::BadNameValue(_, _)
));
}
@@ -201,7 +201,7 @@ fn test_contract_name_serialization_too_long() {
// the first byte is the length of the buffer.
#[rstest]
#[case::invalid_utf8(vec![4, 0xFF, 0xFE, 0xFD, 0xFC], "Failed to parse Contract name: could not construct from utf8")]
-#[case::invalid_name(vec![2, b'2', b'i'], "Failed to parse Contract name: InvalidContractName(\"ContractName\", \"2i\")")] // starts with number
+#[case::invalid_name(vec![2, b'2', b'i'], "Failed to parse Contract name: BadNameValue(\"ContractName\", \"2i\")")] // starts with number
#[case::too_long(vec![MAX_STRING_LEN + 1], &format!("Failed to deserialize contract name: too short or too long: {}", MAX_STRING_LEN + 1))]
#[case::wrong_length(vec![3, b'a'], "failed to fill whole buffer")]
fn test_contract_name_deserialization_errors(#[case] buffer: Vec, #[case] error_message: &str) {
diff --git a/clarity-serialization/src/tests/types/mod.rs b/clarity-serialization/src/tests/types/mod.rs
index 40f6aec738..8dd540986b 100644
--- a/clarity-serialization/src/tests/types/mod.rs
+++ b/clarity-serialization/src/tests/types/mod.rs
@@ -17,7 +17,7 @@ mod signatures;
use stacks_common::types::StacksEpochId;
-use crate::CodecError;
+use crate::errors::{CheckErrors, InterpreterError};
use crate::types::{
BuffData, ListTypeData, MAX_VALUE_SIZE, PrincipalData, SequenceData, TupleData, TypeSignature,
Value,
@@ -25,42 +25,42 @@ use crate::types::{
#[test]
fn test_constructors() {
- assert!(matches!(
+ assert_eq!(
Value::list_with_type(
&StacksEpochId::latest(),
vec![Value::Int(5), Value::Int(2)],
ListTypeData::new_list(TypeSignature::BoolType, 3).unwrap()
),
- Err(CodecError::FailureConstructingListWithType)
- ));
- assert!(matches!(
+ Err(InterpreterError::FailureConstructingListWithType.into())
+ );
+ assert_eq!(
ListTypeData::new_list(TypeSignature::IntType, MAX_VALUE_SIZE),
- Err(CodecError::ValueTooLarge)
- ));
+ Err(CheckErrors::ValueTooLarge)
+ );
- assert!(matches!(
+ assert_eq!(
Value::buff_from(vec![0; (MAX_VALUE_SIZE + 1) as usize]),
- Err(CodecError::ValueTooLarge)
- ));
+ Err(CheckErrors::ValueTooLarge.into())
+ );
// Test that wrappers (okay, error, some)
// correctly error when _they_ cause the value size
// to exceed the max value size (note, the buffer constructor
// isn't causing the error).
- assert!(matches!(
+ assert_eq!(
Value::okay(Value::buff_from(vec![0; (MAX_VALUE_SIZE) as usize]).unwrap()),
- Err(CodecError::ValueTooLarge)
- ));
+ Err(CheckErrors::ValueTooLarge.into())
+ );
- assert!(matches!(
+ assert_eq!(
Value::error(Value::buff_from(vec![0; (MAX_VALUE_SIZE) as usize]).unwrap()),
- Err(CodecError::ValueTooLarge)
- ));
+ Err(CheckErrors::ValueTooLarge.into())
+ );
- assert!(matches!(
+ assert_eq!(
Value::some(Value::buff_from(vec![0; (MAX_VALUE_SIZE) as usize]).unwrap()),
- Err(CodecError::ValueTooLarge)
- ));
+ Err(CheckErrors::ValueTooLarge.into())
+ );
// Test that the depth limit is correctly enforced:
// for tuples, lists, somes, okays, errors.
@@ -81,27 +81,27 @@ fn test_constructors() {
)?)?)?)?)
};
let inner_value = cons().unwrap();
- assert!(matches!(
+ assert_eq!(
TupleData::from_data(vec![("a".into(), inner_value.clone())]),
- Err(CodecError::TypeSignatureTooDeep)
- ));
+ Err(CheckErrors::TypeSignatureTooDeep.into())
+ );
- assert!(matches!(
+ assert_eq!(
Value::list_from(vec![inner_value.clone()]),
- Err(CodecError::TypeSignatureTooDeep)
- ));
- assert!(matches!(
+ Err(CheckErrors::TypeSignatureTooDeep.into())
+ );
+ assert_eq!(
Value::okay(inner_value.clone()),
- Err(CodecError::TypeSignatureTooDeep)
- ));
- assert!(matches!(
+ Err(CheckErrors::TypeSignatureTooDeep.into())
+ );
+ assert_eq!(
Value::error(inner_value.clone()),
- Err(CodecError::TypeSignatureTooDeep)
- ));
- assert!(matches!(
+ Err(CheckErrors::TypeSignatureTooDeep.into())
+ );
+ assert_eq!(
Value::some(inner_value),
- Err(CodecError::TypeSignatureTooDeep)
- ));
+ Err(CheckErrors::TypeSignatureTooDeep.into())
+ );
if std::env::var("CIRCLE_TESTING") == Ok("1".to_string()) {
println!("Skipping allocation test on Circle");
@@ -110,10 +110,10 @@ fn test_constructors() {
// on 32-bit archs, this error cannot even happen, so don't test (and cause an overflow panic)
if (u32::MAX as usize) < usize::MAX {
- assert!(matches!(
+ assert_eq!(
Value::buff_from(vec![0; (u32::MAX as usize) + 10]),
- Err(CodecError::ValueTooLarge)
- ));
+ Err(CheckErrors::ValueTooLarge.into())
+ );
}
}
diff --git a/clarity-serialization/src/tests/types/serialization.rs b/clarity-serialization/src/tests/types/serialization.rs
index 5e6112d061..4d3f63df32 100644
--- a/clarity-serialization/src/tests/types/serialization.rs
+++ b/clarity-serialization/src/tests/types/serialization.rs
@@ -14,7 +14,8 @@
// along with this program. If not, see .
use std::io::Write;
-use crate::errors::CodecError;
+use crate::errors::CheckErrors;
+use crate::types::serialization::SerializationError;
use crate::types::{
MAX_VALUE_SIZE, PrincipalData, QualifiedContractIdentifier, StandardPrincipalData, TupleData,
TypeSignature, Value,
@@ -45,7 +46,7 @@ fn test_deser_ser(v: Value) {
fn test_bad_expectation(v: Value, e: TypeSignature) {
assert!(matches!(
Value::try_deserialize_hex(&v.serialize_to_hex().unwrap(), &e, false).unwrap_err(),
- CodecError::DeserializeExpected(_)
+ SerializationError::DeserializeExpected(_)
));
}
@@ -71,10 +72,10 @@ fn test_lists() {
)
.unwrap();
- assert!(matches!(
+ assert_eq!(
Value::deserialize_read(&mut too_big.as_slice(), None, false).unwrap_err(),
- CodecError::Deserialization(e) if e == "Illegal list type"
- ));
+ "Illegal list type".into()
+ );
// make a list that says it is longer than it is!
// this describes a list of size MAX_VALUE_SIZE of Value::Bool(true)'s, but is actually only 59 bools.
@@ -98,11 +99,11 @@ fn test_lists() {
match Value::deserialize_read(&mut eof.as_slice(), None, false) {
Ok(_) => panic!("Accidentally parsed truncated slice"),
Err(eres) => match eres {
- CodecError::Io(io_e) => match io_e.kind() {
+ SerializationError::IOError(ioe) => match ioe.err.kind() {
std::io::ErrorKind::UnexpectedEof => {}
- _ => panic!("Invalid I/O error: {:?}", &io_e),
+ _ => panic!("Invalid I/O error: {ioe:?}"),
},
- _ => panic!("Invalid deserialize error: {:?}", &eres),
+ _ => panic!("Invalid deserialize error: {eres:?}"),
},
}
}
@@ -240,7 +241,7 @@ fn test_tuples() {
false
)
.unwrap_err(),
- CodecError::DeserializeExpected(_)
+ SerializationError::DeserializeExpected(_)
));
// field type mismatch
@@ -251,7 +252,7 @@ fn test_tuples() {
false
)
.unwrap_err(),
- CodecError::DeserializeExpected(_)
+ SerializationError::DeserializeExpected(_)
));
// field not-present in expected
@@ -262,17 +263,14 @@ fn test_tuples() {
false
)
.unwrap_err(),
- CodecError::DeserializeExpected(_)
+ SerializationError::DeserializeExpected(_)
));
}
#[test]
fn test_vectors() {
let tests = [
- (
- "1010",
- Err(CodecError::Deserialization("Bad type prefix".to_string())),
- ),
+ ("1010", Err("Bad type prefix".into())),
("0000000000000000000000000000000001", Ok(Value::Int(1))),
("00ffffffffffffffffffffffffffffffff", Ok(Value::Int(-1))),
("0100000000000000000000000000000001", Ok(Value::UInt(1))),
@@ -373,10 +371,10 @@ fn try_deser_large_list() {
11, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
];
- assert!(matches!(
+ assert_eq!(
Value::try_deserialize_bytes_untyped(&buff).unwrap_err(),
- CodecError::Deserialization(e) if e == "Illegal list type"
- ));
+ SerializationError::DeserializationError("Illegal list type".to_string())
+ );
}
#[test]
@@ -385,19 +383,19 @@ fn try_deser_large_tuple() {
12, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
];
- assert!(matches!(
+ assert_eq!(
Value::try_deserialize_bytes_untyped(&buff).unwrap_err(),
- CodecError::Deserialization(e) if e == "Illegal tuple type"
- ));
+ SerializationError::DeserializationError("Illegal tuple type".to_string())
+ );
}
#[test]
fn try_overflow_stack() {
let input = "08080808080808080808070707080807080808080808080708080808080708080707080707080807080808080808080708080808080708080707080708070807080808080808080708080808080708080708080808080808080807070807080808080808070808070707080807070808070808080808070808070708070807080808080808080707080708070807080708080808080808070808080808070808070808080808080808080707080708080808080807080807070708080707080807080808080807080807070807080708080808080808070708070808080808080708080707070808070708080807080807070708";
- assert!(matches!(
- Value::try_deserialize_hex_untyped(input),
- Err(CodecError::TypeSignatureTooDeep)
- ));
+ assert_eq!(
+ Err(CheckErrors::TypeSignatureTooDeep.into()),
+ Value::try_deserialize_hex_untyped(input)
+ );
}
#[test]
diff --git a/clarity-serialization/src/tests/types/signatures.rs b/clarity-serialization/src/tests/types/signatures.rs
index d04949c183..3569cf4fbd 100644
--- a/clarity-serialization/src/tests/types/signatures.rs
+++ b/clarity-serialization/src/tests/types/signatures.rs
@@ -14,7 +14,7 @@
// along with this program. If not, see .
use std::collections::HashSet;
-use crate::errors::CodecError;
+use crate::errors::CheckErrors;
use crate::types::TypeSignature::{BoolType, IntType, ListUnionType, UIntType};
use crate::types::signatures::{CallableSubtype, TypeSignature};
use crate::types::{
@@ -517,11 +517,11 @@ fn test_least_supertype() {
for pair in bad_pairs {
matches!(
TypeSignature::least_supertype_v2_1(&pair.0, &pair.1).unwrap_err(),
- CodecError::TypeError { .. }
+ CheckErrors::TypeError(..)
);
matches!(
TypeSignature::least_supertype_v2_1(&pair.1, &pair.0).unwrap_err(),
- CodecError::TypeError { .. }
+ CheckErrors::TypeError(..)
);
}
}
diff --git a/clarity-serialization/src/token.rs b/clarity-serialization/src/token.rs
new file mode 100644
index 0000000000..0411a0f07f
--- /dev/null
+++ b/clarity-serialization/src/token.rs
@@ -0,0 +1,124 @@
+// 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 .
+use std::fmt::Display;
+
+use crate::representations::Span;
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum Token {
+ Eof,
+ Whitespace,
+ Lparen,
+ Rparen,
+ Lbrace,
+ Rbrace,
+ Colon,
+ Comma,
+ Dot,
+ Int(String),
+ Uint(String),
+ AsciiString(String),
+ Utf8String(String),
+ Bytes(String),
+ Principal(String),
+ Ident(String),
+ TraitIdent(String),
+ Plus,
+ Minus,
+ Multiply,
+ Divide,
+ Less,
+ LessEqual,
+ Greater,
+ GreaterEqual,
+ Comment(String),
+ Placeholder(String), // used to continue parsing after errors
+}
+
+impl Display for Token {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ use self::Token::*;
+ match self {
+ Eof => write!(f, "EOF"),
+ Whitespace => write!(f, "whitespace"),
+ Lparen => write!(f, "("),
+ Rparen => write!(f, ")"),
+ Lbrace => write!(f, "{{"),
+ Rbrace => write!(f, "}}"),
+ Colon => write!(f, ":"),
+ Comma => write!(f, ","),
+ Dot => write!(f, "."),
+ Int(_) => write!(f, "int"),
+ Uint(_) => write!(f, "uint"),
+ AsciiString(_) => write!(f, "string-ascii"),
+ Utf8String(_) => write!(f, "string-utf8"),
+ Bytes(_) => write!(f, "bytes"),
+ Principal(_) => write!(f, "principal"),
+ Ident(_) => write!(f, "identifier"),
+ TraitIdent(_) => write!(f, "trait-identifier"),
+ Plus => write!(f, "+"),
+ Minus => write!(f, "-"),
+ Multiply => write!(f, "*"),
+ Divide => write!(f, "/"),
+ Less => write!(f, "<"),
+ LessEqual => write!(f, "<="),
+ Greater => write!(f, ">"),
+ GreaterEqual => write!(f, ">="),
+ Comment(_) => write!(f, "comment"),
+ Placeholder(_) => write!(f, "placeholder"),
+ }
+ }
+}
+
+impl Token {
+ pub fn reproduce(&self) -> String {
+ use self::Token::*;
+ match self {
+ Eof => "".to_string(),
+ Whitespace => " ".to_string(),
+ Lparen => "(".to_string(),
+ Rparen => ")".to_string(),
+ Lbrace => "{{".to_string(),
+ Rbrace => "}}".to_string(),
+ Colon => ":".to_string(),
+ Comma => ",".to_string(),
+ Dot => ".".to_string(),
+ Int(s) => s.to_string(),
+ Uint(s) => format!("u{s}"),
+ AsciiString(s) => format!("\"{s}\""),
+ Utf8String(s) => s.to_string(),
+ Bytes(s) => format!("0x{s}"),
+ Principal(s) => format!("'{s}"),
+ Ident(s) => s.to_string(),
+ TraitIdent(s) => format!("<{s}>"),
+ Plus => "+".to_string(),
+ Minus => "-".to_string(),
+ Multiply => "*".to_string(),
+ Divide => "/".to_string(),
+ Less => "<".to_string(),
+ LessEqual => "<=".to_string(),
+ Greater => ">".to_string(),
+ GreaterEqual => ">=".to_string(),
+ Comment(c) => format!(";; {c}"),
+ Placeholder(s) => s.to_string(),
+ }
+ }
+}
+
+#[derive(Clone, Debug)]
+pub struct PlacedToken {
+ pub span: Span,
+ pub token: Token,
+}
diff --git a/clarity-serialization/src/types/mod.rs b/clarity-serialization/src/types/mod.rs
index 61f69ec174..6b347583da 100644
--- a/clarity-serialization/src/types/mod.rs
+++ b/clarity-serialization/src/types/mod.rs
@@ -12,6 +12,7 @@
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
+#![allow(clippy::result_large_err)]
pub mod serialization;
pub mod signatures;
@@ -25,6 +26,8 @@ use serde::{Deserialize, Serialize};
use stacks_common::address::c32;
use stacks_common::types::StacksEpochId;
use stacks_common::types::chainstate::StacksAddress;
+#[cfg(feature = "testing")]
+use stacks_common::types::chainstate::StacksPrivateKey;
use stacks_common::util::hash;
pub use self::signatures::{
@@ -32,8 +35,8 @@ pub use self::signatures::{
ListTypeData, SequenceSubtype, StringSubtype, StringUTF8Length, TupleTypeSignature,
TypeSignature,
};
-use crate::errors::CodecError;
-use crate::representations::{ClarityName, ContractName};
+use crate::errors::{CheckErrors, InterpreterError, InterpreterResult as Result, RuntimeErrorType};
+use crate::representations::{ClarityName, ContractName, SymbolicExpression};
// use crate::vm::ClarityVersion;
pub const MAX_VALUE_SIZE: u32 = 1024 * 1024; // 1MB
@@ -76,9 +79,9 @@ impl StandardPrincipalData {
}
impl StandardPrincipalData {
- pub fn new(version: u8, bytes: [u8; 20]) -> Result {
+ pub fn new(version: u8, bytes: [u8; 20]) -> std::result::Result {
if version >= 32 {
- return Err(CodecError::Expect("Unexpected principal data".into()));
+ return Err(InterpreterError::Expect("Unexpected principal data".into()));
}
Ok(Self(version, bytes))
}
@@ -122,6 +125,23 @@ impl fmt::Debug for StandardPrincipalData {
}
}
+#[cfg(any(test, feature = "testing"))]
+impl From<&StacksPrivateKey> for StandardPrincipalData {
+ fn from(o: &StacksPrivateKey) -> StandardPrincipalData {
+ use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
+ use stacks_common::types::chainstate::StacksPublicKey;
+
+ let stacks_addr = StacksAddress::from_public_keys(
+ C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+ &AddressHashMode::SerializeP2PKH,
+ 1,
+ &vec![StacksPublicKey::from_private(o)],
+ )
+ .unwrap();
+ StandardPrincipalData::from(stacks_addr)
+ }
+}
+
#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize, PartialOrd, Ord)]
pub struct QualifiedContractIdentifier {
pub issuer: StandardPrincipalData,
@@ -133,7 +153,7 @@ impl QualifiedContractIdentifier {
Self { issuer, name }
}
- pub fn local(name: &str) -> Result {
+ pub fn local(name: &str) -> Result {
let name = name.to_string().try_into()?;
Ok(Self::new(StandardPrincipalData::transient(), name))
}
@@ -152,13 +172,14 @@ impl QualifiedContractIdentifier {
self.issuer.1 == [0; 20]
}
- pub fn parse(literal: &str) -> Result {
+ pub fn parse(literal: &str) -> Result {
let split: Vec<_> = literal.splitn(2, '.').collect();
if split.len() != 2 {
- return Err(CodecError::ParseError(
+ return Err(RuntimeErrorType::ParseError(
"Invalid principal literal: expected a `.` in a qualified contract name"
.to_string(),
- ));
+ )
+ .into());
}
let sender = PrincipalData::parse_standard_principal(split[0])?;
let name = split[1].to_string().try_into()?;
@@ -178,6 +199,13 @@ pub enum PrincipalData {
Contract(QualifiedContractIdentifier),
}
+#[cfg(any(test, feature = "testing"))]
+impl From<&StacksPrivateKey> for PrincipalData {
+ fn from(o: &StacksPrivateKey) -> PrincipalData {
+ PrincipalData::Standard(StandardPrincipalData::from(o))
+ }
+}
+
pub enum ContractIdentifier {
Relative(ContractName),
Qualified(QualifiedContractIdentifier),
@@ -233,26 +261,27 @@ impl TraitIdentifier {
}
}
- pub fn parse_fully_qualified(literal: &str) -> Result {
+ pub fn parse_fully_qualified(literal: &str) -> Result {
let (issuer, contract_name, name) = Self::parse(literal)?;
- let issuer = issuer.ok_or(CodecError::BadTypeConstruction)?;
+ let issuer = issuer.ok_or(RuntimeErrorType::BadTypeConstruction)?;
Ok(TraitIdentifier::new(issuer, contract_name, name))
}
- pub fn parse_sugared_syntax(literal: &str) -> Result<(ContractName, ClarityName), CodecError> {
+ pub fn parse_sugared_syntax(literal: &str) -> Result<(ContractName, ClarityName)> {
let (_, contract_name, name) = Self::parse(literal)?;
Ok((contract_name, name))
}
pub fn parse(
literal: &str,
- ) -> Result<(Option, ContractName, ClarityName), CodecError> {
+ ) -> Result<(Option, ContractName, ClarityName)> {
let split: Vec<_> = literal.splitn(3, '.').collect();
if split.len() != 3 {
- return Err(CodecError::ParseError(
+ return Err(RuntimeErrorType::ParseError(
"Invalid principal literal: expected a `.` in a qualified contract name"
.to_string(),
- ));
+ )
+ .into());
}
let issuer = match split[0].len() {
@@ -290,7 +319,16 @@ pub enum SequenceData {
}
impl SequenceData {
- pub fn element_size(&self) -> Result {
+ pub fn atom_values(&mut self) -> Result> {
+ match self {
+ SequenceData::Buffer(data) => data.atom_values(),
+ SequenceData::List(data) => data.atom_values(),
+ SequenceData::String(CharType::ASCII(data)) => data.atom_values(),
+ SequenceData::String(CharType::UTF8(data)) => data.atom_values(),
+ }
+ }
+
+ pub fn element_size(&self) -> Result {
let out = match self {
SequenceData::Buffer(..) => TypeSignature::min_buffer()?.size(),
SequenceData::List(data) => data.type_signature.get_list_item_type().size(),
@@ -312,10 +350,8 @@ impl SequenceData {
pub fn is_empty(&self) -> bool {
self.len() == 0
}
-}
-impl SequenceData {
- pub fn element_at(self, index: usize) -> Result, CodecError> {
+ pub fn element_at(self, index: usize) -> Result> {
if self.len() <= index {
return Ok(None);
}
@@ -324,7 +360,9 @@ impl SequenceData {
SequenceData::List(mut data) => data.data.remove(index),
SequenceData::String(CharType::ASCII(data)) => {
Value::string_ascii_from_bytes(vec![data.data[index]]).map_err(|_| {
- CodecError::Expect("BUG: failed to initialize single-byte ASCII buffer".into())
+ InterpreterError::Expect(
+ "BUG: failed to initialize single-byte ASCII buffer".into(),
+ )
})?
}
SequenceData::String(CharType::UTF8(mut data)) => {
@@ -337,12 +375,7 @@ impl SequenceData {
Ok(Some(result))
}
- pub fn replace_at(
- self,
- epoch: &StacksEpochId,
- index: usize,
- element: Value,
- ) -> Result {
+ pub fn replace_at(self, epoch: &StacksEpochId, index: usize, element: Value) -> Result {
let seq_length = self.len();
// Check that the length of the provided element is 1. In the case that SequenceData
@@ -351,14 +384,14 @@ impl SequenceData {
if let Value::Sequence(data) = &element {
let elem_length = data.len();
if elem_length != 1 {
- return Err(CodecError::BadTypeConstruction);
+ return Err(RuntimeErrorType::BadTypeConstruction.into());
}
} else {
- return Err(CodecError::BadTypeConstruction);
+ return Err(RuntimeErrorType::BadTypeConstruction.into());
}
}
if index >= seq_length {
- return Err(CodecError::ValueOutOfBounds);
+ return Err(CheckErrors::ValueOutOfBounds.into());
}
let new_seq_data = match (self, element) {
@@ -369,7 +402,7 @@ impl SequenceData {
(SequenceData::List(mut data), elem) => {
let entry_type = data.type_signature.get_list_item_type();
if !entry_type.admits(epoch, &elem)? {
- return Err(CodecError::ListTypesMustMatch);
+ return Err(CheckErrors::ListTypesMustMatch.into());
}
data.data[index] = elem;
SequenceData::List(data)
@@ -388,13 +421,13 @@ impl SequenceData {
data.data[index] = elem.data.swap_remove(0);
SequenceData::String(CharType::UTF8(data))
}
- _ => return Err(CodecError::ListTypesMustMatch),
+ _ => return Err(CheckErrors::ListTypesMustMatch.into()),
};
Value::some(Value::Sequence(new_seq_data))
}
- pub fn contains(&self, to_find: Value) -> Result, CodecError> {
+ pub fn contains(&self, to_find: Value) -> Result> {
match self {
SequenceData::Buffer(data) => {
if let Value::Sequence(SequenceData::Buffer(to_find_vec)) = to_find {
@@ -409,10 +442,7 @@ impl SequenceData {
Ok(None)
}
} else {
- Err(CodecError::TypeValueError {
- expected: Box::new(TypeSignature::min_buffer()?),
- found: Box::new(to_find),
- })
+ Err(CheckErrors::TypeValueError(TypeSignature::min_buffer()?, to_find).into())
}
}
SequenceData::List(data) => {
@@ -437,10 +467,10 @@ impl SequenceData {
Ok(None)
}
} else {
- Err(CodecError::TypeValueError {
- expected: Box::new(TypeSignature::min_string_ascii()?),
- found: Box::new(to_find),
- })
+ Err(
+ CheckErrors::TypeValueError(TypeSignature::min_string_ascii()?, to_find)
+ .into(),
+ )
}
}
SequenceData::String(CharType::UTF8(data)) => {
@@ -457,20 +487,59 @@ impl SequenceData {
Ok(None)
}
} else {
- Err(CodecError::TypeValueError {
- expected: Box::new(TypeSignature::min_string_utf8()?),
- found: Box::new(to_find),
- })
+ Err(
+ CheckErrors::TypeValueError(TypeSignature::min_string_utf8()?, to_find)
+ .into(),
+ )
}
}
}
}
- pub fn concat(
- &mut self,
- epoch: &StacksEpochId,
- other_seq: SequenceData,
- ) -> Result<(), CodecError> {
+ pub fn filter(&mut self, filter: &mut F) -> Result<()>
+ where
+ F: FnMut(SymbolicExpression) -> Result,
+ {
+ // Note: this macro can probably get removed once
+ // ```Vec::drain_filter(&mut self, filter: F) -> DrainFilter```
+ // is available in rust stable channel (experimental at this point).
+ macro_rules! drain_filter {
+ ($data:expr, $seq_type:ident) => {
+ let mut i = 0;
+ while i != $data.data.len() {
+ let atom_value =
+ SymbolicExpression::atom_value($seq_type::to_value(&$data.data[i])?);
+ match filter(atom_value) {
+ Ok(res) if res == false => {
+ $data.data.remove(i);
+ }
+ Ok(_) => {
+ i += 1;
+ }
+ Err(err) => return Err(err),
+ }
+ }
+ };
+ }
+
+ match self {
+ SequenceData::Buffer(data) => {
+ drain_filter!(data, BuffData);
+ }
+ SequenceData::List(data) => {
+ drain_filter!(data, ListData);
+ }
+ SequenceData::String(CharType::ASCII(data)) => {
+ drain_filter!(data, ASCIIData);
+ }
+ SequenceData::String(CharType::UTF8(data)) => {
+ drain_filter!(data, UTF8Data);
+ }
+ }
+ Ok(())
+ }
+
+ pub fn concat(&mut self, epoch: &StacksEpochId, other_seq: SequenceData) -> Result<()> {
match (self, other_seq) {
(SequenceData::List(inner_data), SequenceData::List(other_inner_data)) => {
inner_data.append(epoch, other_inner_data)
@@ -486,7 +555,7 @@ impl SequenceData {
SequenceData::String(CharType::UTF8(inner_data)),
SequenceData::String(CharType::UTF8(ref mut other_inner_data)),
) => inner_data.append(other_inner_data),
- _ => Err(CodecError::BadTypeConstruction),
+ _ => Err(RuntimeErrorType::BadTypeConstruction.into()),
}?;
Ok(())
}
@@ -496,7 +565,7 @@ impl SequenceData {
epoch: &StacksEpochId,
left_position: usize,
right_position: usize,
- ) -> Result {
+ ) -> Result {
let empty_seq = left_position == right_position;
let result = match self {
@@ -604,30 +673,38 @@ impl fmt::Display for UTF8Data {
}
pub trait SequencedValue {
- fn type_signature(&self) -> Result;
+ fn type_signature(&self) -> std::result::Result;
fn items(&self) -> &Vec;
fn drained_items(&mut self) -> Vec;
- fn to_value(v: &T) -> Result;
+ fn to_value(v: &T) -> Result;
+
+ fn atom_values(&mut self) -> Result> {
+ self.drained_items()
+ .iter()
+ .map(|item| Ok(SymbolicExpression::atom_value(Self::to_value(item)?)))
+ .collect()
+ }
}
impl SequencedValue for ListData {
fn items(&self) -> &Vec {
&self.data
}
+
fn drained_items(&mut self) -> Vec {
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(),
)))
}
- fn to_value(v: &Value) -> Result {
+ fn to_value(v: &Value) -> Result {
Ok(v.clone())
}
}
@@ -641,16 +718,16 @@ 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(|_| {
- CodecError::Expect("ERROR: Too large of a buffer successfully constructed.".into())
+ CheckErrors::Expects("ERROR: Too large of a buffer successfully constructed.".into())
})?;
Ok(TypeSignature::SequenceType(SequenceSubtype::BufferType(
buff_length,
)))
}
- fn to_value(v: &u8) -> Result {
+ fn to_value(v: &u8) -> Result {
Ok(Value::buff_from_byte(*v))
}
}
@@ -664,18 +741,19 @@ 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(|_| {
- CodecError::Expect("ERROR: Too large of a buffer successfully constructed.".into())
+ CheckErrors::Expects("ERROR: Too large of a buffer successfully constructed.".into())
})?;
Ok(TypeSignature::SequenceType(SequenceSubtype::StringType(
StringSubtype::ASCII(buff_length),
)))
}
- fn to_value(v: &u8) -> Result {
+ fn to_value(v: &u8) -> Result {
Value::string_ascii_from_bytes(vec![*v]).map_err(|_| {
- CodecError::Expect("ERROR: Invalid ASCII string successfully constructed".into())
+ InterpreterError::Expect("ERROR: Invalid ASCII string successfully constructed".into())
+ .into()
})
}
}
@@ -689,36 +767,37 @@ 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(|_| {
- CodecError::Expect("ERROR: Too large of a buffer successfully constructed.".into())
+ CheckErrors::Expects("ERROR: Too large of a buffer successfully constructed.".into())
})?;
Ok(TypeSignature::SequenceType(SequenceSubtype::StringType(
StringSubtype::UTF8(str_len),
)))
}
- fn to_value(v: &Vec) -> Result {
+ fn to_value(v: &Vec) -> Result {
Value::string_utf8_from_bytes(v.clone()).map_err(|_| {
- CodecError::Expect("ERROR: Invalid UTF8 string successfully constructed".into())
+ InterpreterError::Expect("ERROR: Invalid UTF8 string successfully constructed".into())
+ .into()
})
}
}
impl OptionalData {
- pub fn type_signature(&self) -> 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(|_| {
- CodecError::Expect("Should not have constructed too large of a type.".into())
+ CheckErrors::Expects("Should not have constructed too large of a type.".into())
})
}
}
impl ResponseData {
- pub fn type_signature(&self) -> Result {
+ pub fn type_signature(&self) -> std::result::Result {
let type_result = match self.committed {
true => TypeSignature::new_response(
TypeSignature::type_of(&self.data)?,
@@ -730,7 +809,7 @@ impl ResponseData {
),
};
type_result.map_err(|_| {
- CodecError::Expect("Should not have constructed too large of a type.".into())
+ CheckErrors::Expects("Should not have constructed too large of a type.".into())
})
}
}
@@ -750,11 +829,11 @@ impl PartialEq for TupleData {
pub const NONE: Value = Value::Optional(OptionalData { data: None });
impl Value {
- pub fn some(data: Value) -> Result {
+ pub fn some(data: Value) -> Result {
if data.size()? + WRAPPER_VALUE_SIZE > MAX_VALUE_SIZE {
- Err(CodecError::ValueTooLarge)
+ Err(CheckErrors::ValueTooLarge.into())
} else if data.depth()? + 1 > MAX_TYPE_DEPTH {
- Err(CodecError::TypeSignatureTooDeep)
+ Err(CheckErrors::TypeSignatureTooDeep.into())
} else {
Ok(Value::Optional(OptionalData {
data: Some(Box::new(data)),
@@ -787,11 +866,11 @@ impl Value {
})
}
- pub fn okay(data: Value) -> Result {
+ pub fn okay(data: Value) -> Result {
if data.size()? + WRAPPER_VALUE_SIZE > MAX_VALUE_SIZE {
- Err(CodecError::ValueTooLarge)
+ Err(CheckErrors::ValueTooLarge.into())
} else if data.depth()? + 1 > MAX_TYPE_DEPTH {
- Err(CodecError::TypeSignatureTooDeep)
+ Err(CheckErrors::TypeSignatureTooDeep.into())
} else {
Ok(Value::Response(ResponseData {
committed: true,
@@ -800,11 +879,11 @@ impl Value {
}
}
- pub fn error(data: Value) -> Result {
+ pub fn error(data: Value) -> Result {
if data.size()? + WRAPPER_VALUE_SIZE > MAX_VALUE_SIZE {
- Err(CodecError::ValueTooLarge)
+ Err(CheckErrors::ValueTooLarge.into())
} else if data.depth()? + 1 > MAX_TYPE_DEPTH {
- Err(CodecError::TypeSignatureTooDeep)
+ Err(CheckErrors::TypeSignatureTooDeep.into())
} else {
Ok(Value::Response(ResponseData {
committed: false,
@@ -813,11 +892,11 @@ impl Value {
}
}
- pub fn size(&self) -> Result {
- TypeSignature::type_of(self)?.size()
+ pub fn size(&self) -> Result {
+ Ok(TypeSignature::type_of(self)?.size()?)
}
- pub fn depth(&self) -> Result {
+ pub fn depth(&self) -> Result {
Ok(TypeSignature::type_of(self)?.depth())
}
@@ -828,12 +907,12 @@ impl Value {
epoch: &StacksEpochId,
list_data: Vec,
expected_type: ListTypeData,
- ) -> Result {
+ ) -> Result {
// Constructors for TypeSignature ensure that the size of the Value cannot
// be greater than MAX_VALUE_SIZE (they error on such constructions)
// so we do not need to perform that check here.
if (expected_type.get_max_len() as usize) < list_data.len() {
- return Err(CodecError::FailureConstructingListWithType);
+ return Err(InterpreterError::FailureConstructingListWithType.into());
}
{
@@ -841,7 +920,7 @@ impl Value {
for item in &list_data {
if !expected_item_type.admits(epoch, item)? {
- return Err(CodecError::FailureConstructingListWithType);
+ return Err(InterpreterError::FailureConstructingListWithType.into());
}
}
}
@@ -852,7 +931,7 @@ impl Value {
})))
}
- pub fn cons_list_unsanitized(list_data: Vec) -> Result {
+ pub fn cons_list_unsanitized(list_data: Vec) -> Result {
let type_sig = TypeSignature::construct_parent_list_type(&list_data)?;
Ok(Value::Sequence(SequenceData::List(ListData {
data: list_data,
@@ -861,11 +940,11 @@ impl Value {
}
#[cfg(any(test, feature = "testing"))]
- pub fn list_from(list_data: Vec) -> Result {
+ pub fn list_from(list_data: Vec) -> Result {
Value::cons_list_unsanitized(list_data)
}
- pub fn cons_list(list_data: Vec, epoch: &StacksEpochId) -> Result {
+ pub fn cons_list(list_data: Vec, epoch: &StacksEpochId) -> Result {
// Constructors for TypeSignature ensure that the size of the Value cannot
// be greater than MAX_VALUE_SIZE (they error on such constructions)
// Aaron: at this point, we've _already_ allocated memory for this type.
@@ -880,7 +959,7 @@ impl Value {
.map(|(value, _did_sanitize)| value)
})
.collect();
- let list_data = list_data_opt.ok_or_else(|| CodecError::ListTypesMustMatch)?;
+ let list_data = list_data_opt.ok_or_else(|| CheckErrors::ListTypesMustMatch)?;
Ok(Value::Sequence(SequenceData::List(ListData {
data: list_data,
type_signature: type_sig,
@@ -888,8 +967,8 @@ impl Value {
}
/// # Errors
- /// - [`CodecError::ValueTooLarge`] if `buff_data` is too large.
- pub fn buff_from(buff_data: Vec) -> Result {
+ /// - CheckErrors::ValueTooLarge if `buff_data` is too large.
+ pub fn buff_from(buff_data: Vec) -> Result {
// check the buffer size
BufferLength::try_from(buff_data.len())?;
// construct the buffer
@@ -902,13 +981,13 @@ impl Value {
Value::Sequence(SequenceData::Buffer(BuffData { data: vec![byte] }))
}
- pub fn string_ascii_from_bytes(bytes: Vec) -> Result {
+ pub fn string_ascii_from_bytes(bytes: Vec) -> Result {
// check the string size
BufferLength::try_from(bytes.len())?;
for b in bytes.iter() {
if !b.is_ascii_alphanumeric() && !b.is_ascii_punctuation() && !b.is_ascii_whitespace() {
- return Err(CodecError::InvalidStringCharacters);
+ return Err(CheckErrors::InvalidCharactersDetected.into());
}
}
// construct the string
@@ -917,11 +996,9 @@ impl Value {
))))
}
- pub fn string_utf8_from_string_utf8_literal(
- tokenized_str: String,
- ) -> Result {
+ pub fn string_utf8_from_string_utf8_literal(tokenized_str: String) -> Result {
let wrapped_codepoints_matcher = Regex::new("^\\\\u\\{(?P[[:xdigit:]]+)\\}")
- .map_err(|_| CodecError::Expect("Bad regex".into()))?;
+ .map_err(|_| InterpreterError::Expect("Bad regex".into()))?;
let mut window = tokenized_str.as_str();
let mut cursor = 0;
let mut data: Vec> = vec![];
@@ -929,12 +1006,12 @@ impl Value {
if let Some(captures) = wrapped_codepoints_matcher.captures(window) {
let matched = captures
.name("value")
- .ok_or_else(|| CodecError::Expect("Expected capture".into()))?;
+ .ok_or_else(|| InterpreterError::Expect("Expected capture".into()))?;
let scalar_value = window[matched.start()..matched.end()].to_string();
let unicode_char = {
let u = u32::from_str_radix(&scalar_value, 16)
- .map_err(|_| CodecError::InvalidUtf8Encoding)?;
- let c = char::from_u32(u).ok_or_else(|| CodecError::InvalidUtf8Encoding)?;
+ .map_err(|_| CheckErrors::InvalidUTF8Encoding)?;
+ let c = char::from_u32(u).ok_or_else(|| CheckErrors::InvalidUTF8Encoding)?;
let mut encoded_char: Vec = vec![0; c.len_utf8()];
c.encode_utf8(&mut encoded_char[..]);
encoded_char
@@ -958,10 +1035,10 @@ impl Value {
))))
}
- pub fn string_utf8_from_bytes(bytes: Vec) -> Result {
+ pub fn string_utf8_from_bytes(bytes: Vec) -> Result {
let validated_utf8_str = match str::from_utf8(&bytes) {
Ok(string) => string,
- _ => return Err(CodecError::InvalidStringCharacters),
+ _ => return Err(CheckErrors::InvalidCharactersDetected.into()),
};
let data = validated_utf8_str
.chars()
@@ -979,35 +1056,35 @@ impl Value {
))))
}
- pub fn expect_ascii(self) -> Result {
+ pub fn expect_ascii(self) -> Result {
if let Value::Sequence(SequenceData::String(CharType::ASCII(ASCIIData { data }))) = self {
Ok(String::from_utf8(data)
- .map_err(|_| CodecError::Expect("Non UTF-8 data in string".into()))?)
+ .map_err(|_| InterpreterError::Expect("Non UTF-8 data in string".into()))?)
} else {
error!("Value '{self:?}' is not an ASCII string");
- Err(CodecError::Expect("Expected ASCII string".into()))
+ Err(InterpreterError::Expect("Expected ASCII string".into()).into())
}
}
- pub fn expect_u128(self) -> Result {
+ pub fn expect_u128(self) -> Result {
if let Value::UInt(inner) = self {
Ok(inner)
} else {
error!("Value '{self:?}' is not a u128");
- Err(CodecError::Expect("Expected u128".into()))
+ Err(InterpreterError::Expect("Expected u128".into()).into())
}
}
- pub fn expect_i128(self) -> Result {
+ pub fn expect_i128(self) -> Result {
if let Value::Int(inner) = self {
Ok(inner)
} else {
error!("Value '{self:?}' is not an i128");
- Err(CodecError::Expect("Expected i128".into()))
+ Err(InterpreterError::Expect("Expected i128".into()).into())
}
}
- pub fn expect_buff(self, sz: usize) -> Result, CodecError> {
+ pub fn expect_buff(self, sz: usize) -> Result> {
if let Value::Sequence(SequenceData::Buffer(buffdata)) = self {
if buffdata.data.len() <= sz {
Ok(buffdata.data)
@@ -1016,24 +1093,24 @@ impl Value {
"Value buffer has len {}, expected {sz}",
buffdata.data.len()
);
- Err(CodecError::Expect("Unexpected buff length".into()))
+ Err(InterpreterError::Expect("Unexpected buff length".into()).into())
}
} else {
error!("Value '{self:?}' is not a buff");
- Err(CodecError::Expect("Expected buff".into()))
+ Err(InterpreterError::Expect("Expected buff".into()).into())
}
}
- pub fn expect_list(self) -> Result, CodecError> {
+ pub fn expect_list(self) -> Result> {
if let Value::Sequence(SequenceData::List(listdata)) = self {
Ok(listdata.data)
} else {
error!("Value '{self:?}' is not a list");
- Err(CodecError::Expect("Expected list".into()))
+ Err(InterpreterError::Expect("Expected list".into()).into())
}
}
- pub fn expect_buff_padded(self, sz: usize, pad: u8) -> Result, CodecError> {
+ pub fn expect_buff_padded(self, sz: usize, pad: u8) -> Result> {
let mut data = self.expect_buff(sz)?;
if sz > data.len() {
for _ in data.len()..sz {
@@ -1043,25 +1120,25 @@ impl Value {
Ok(data)
}
- pub fn expect_bool(self) -> Result {
+ pub fn expect_bool(self) -> Result {
if let Value::Bool(b) = self {
Ok(b)
} else {
error!("Value '{self:?}' is not a bool");
- Err(CodecError::Expect("Expected bool".into()))
+ Err(InterpreterError::Expect("Expected bool".into()).into())
}
}
- pub fn expect_tuple(self) -> Result {
+ pub fn expect_tuple(self) -> Result {
if let Value::Tuple(data) = self {
Ok(data)
} else {
error!("Value '{self:?}' is not a tuple");
- Err(CodecError::Expect("Expected tuple".into()))
+ Err(InterpreterError::Expect("Expected tuple".into()).into())
}
}
- pub fn expect_optional(self) -> Result, CodecError> {
+ pub fn expect_optional(self) -> Result> {
if let Value::Optional(opt) = self {
match opt.data {
Some(boxed_value) => Ok(Some(*boxed_value)),
@@ -1069,29 +1146,29 @@ impl Value {
}
} else {
error!("Value '{self:?}' is not an optional");
- Err(CodecError::Expect("Expected optional".into()))
+ Err(InterpreterError::Expect("Expected optional".into()).into())
}
}
- pub fn expect_principal(self) -> Result {
+ pub fn expect_principal(self) -> Result {
if let Value::Principal(p) = self {
Ok(p)
} else {
error!("Value '{self:?}' is not a principal");
- Err(CodecError::Expect("Expected principal".into()))
+ Err(InterpreterError::Expect("Expected principal".into()).into())
}
}
- pub fn expect_callable(self) -> Result {
+ pub fn expect_callable(self) -> Result {
if let Value::CallableContract(t) = self {
Ok(t)
} else {
error!("Value '{self:?}' is not a callable contract");
- Err(CodecError::Expect("Expected callable".into()))
+ Err(InterpreterError::Expect("Expected callable".into()).into())
}
}
- pub fn expect_result(self) -> Result, CodecError> {
+ pub fn expect_result(self) -> Result> {
if let Value::Response(res_data) = self {
if res_data.committed {
Ok(Ok(*res_data.data))
@@ -1100,52 +1177,52 @@ impl Value {
}
} else {
error!("Value '{self:?}' is not a response");
- Err(CodecError::Expect("Expected response".into()))
+ Err(InterpreterError::Expect("Expected response".into()).into())
}
}
- pub fn expect_result_ok(self) -> Result {
+ pub fn expect_result_ok(self) -> Result {
if let Value::Response(res_data) = self {
if res_data.committed {
Ok(*res_data.data)
} else {
error!("Value is not a (ok ..)");
- Err(CodecError::Expect("Expected ok response".into()))
+ Err(InterpreterError::Expect("Expected ok response".into()).into())
}
} else {
error!("Value '{self:?}' is not a response");
- Err(CodecError::Expect("Expected response".into()))
+ Err(InterpreterError::Expect("Expected response".into()).into())
}
}
- pub fn expect_result_err(self) -> Result {
+ pub fn expect_result_err(self) -> Result {
if let Value::Response(res_data) = self {
if !res_data.committed {
Ok(*res_data.data)
} else {
error!("Value is not a (err ..)");
- Err(CodecError::Expect("Expected err response".into()))
+ Err(InterpreterError::Expect("Expected err response".into()).into())
}
} else {
error!("Value '{self:?}' is not a response");
- Err(CodecError::Expect("Expected response".into()))
+ Err(InterpreterError::Expect("Expected response".into()).into())
}
}
}
impl BuffData {
- pub fn len(&self) -> Result {
+ pub fn len(&self) -> Result {
self.data
.len()
.try_into()
- .map_err(|_| CodecError::Expect("Data length should be valid".into()))
+ .map_err(|_| InterpreterError::Expect("Data length should be valid".into()).into())
}
pub fn as_slice(&self) -> &[u8] {
self.data.as_slice()
}
- fn append(&mut self, other_seq: &mut BuffData) -> Result<(), CodecError> {
+ fn append(&mut self, other_seq: &mut BuffData) -> Result<()> {
self.data.append(&mut other_seq.data);
Ok(())
}
@@ -1156,25 +1233,25 @@ impl BuffData {
}
impl ListData {
- pub fn len(&self) -> Result {
+ pub fn len(&self) -> Result {
self.data
.len()
.try_into()
- .map_err(|_| CodecError::Expect("Data length should be valid".into()))
+ .map_err(|_| InterpreterError::Expect("Data length should be valid".into()).into())
}
pub fn is_empty(&self) -> bool {
self.data.is_empty()
}
- fn append(&mut self, epoch: &StacksEpochId, other_seq: ListData) -> Result<(), CodecError> {
+ fn append(&mut self, epoch: &StacksEpochId, other_seq: ListData) -> Result<()> {
let entry_type_a = self.type_signature.get_list_item_type();
let entry_type_b = other_seq.type_signature.get_list_item_type();
let entry_type = TypeSignature::factor_out_no_type(epoch, entry_type_a, entry_type_b)?;
let max_len = self.type_signature.get_max_len() + other_seq.type_signature.get_max_len();
for item in other_seq.data.into_iter() {
let (item, _) = Value::sanitize_value(epoch, &entry_type, item)
- .ok_or_else(|| CodecError::ListTypesMustMatch)?;
+ .ok_or_else(|| CheckErrors::ListTypesMustMatch)?;
self.data.push(item);
}
@@ -1184,30 +1261,30 @@ impl ListData {
}
impl ASCIIData {
- fn append(&mut self, other_seq: &mut ASCIIData) -> Result<(), CodecError> {
+ fn append(&mut self, other_seq: &mut ASCIIData) -> Result<()> {
self.data.append(&mut other_seq.data);
Ok(())
}
- pub fn len(&self) -> Result {
+ pub fn len(&self) -> Result {
self.data
.len()
.try_into()
- .map_err(|_| CodecError::Expect("Data length should be valid".into()))
+ .map_err(|_| InterpreterError::Expect("Data length should be valid".into()).into())
}
}
impl UTF8Data {
- fn append(&mut self, other_seq: &mut UTF8Data) -> Result<(), CodecError> {
+ fn append(&mut self, other_seq: &mut UTF8Data) -> Result<()> {
self.data.append(&mut other_seq.data);
Ok(())
}
- pub fn len(&self) -> Result {
+ pub fn len(&self) -> Result {
self.data
.len()
.try_into()
- .map_err(|_| CodecError::Expect("Data length should be valid".into()))
+ .map_err(|_| InterpreterError::Expect("Data length should be valid".into()).into())
}
}
@@ -1251,7 +1328,7 @@ impl fmt::Display for Value {
Value::Principal(principal_data) => write!(f, "{principal_data}"),
Value::Optional(opt_data) => write!(f, "{opt_data}"),
Value::Response(res_data) => write!(f, "{res_data}"),
- Value::Sequence(SequenceData::Buffer(vec_bytes)) => write!(f, "0x{}", &vec_bytes),
+ Value::Sequence(SequenceData::Buffer(vec_bytes)) => write!(f, "0x{vec_bytes}"),
Value::Sequence(SequenceData::String(string)) => write!(f, "{string}"),
Value::Sequence(SequenceData::List(list_data)) => {
write!(f, "(")?;
@@ -1268,6 +1345,13 @@ impl fmt::Display for Value {
}
}
+#[cfg(any(test, feature = "testing"))]
+impl From<&StacksPrivateKey> for Value {
+ fn from(o: &StacksPrivateKey) -> Value {
+ Value::from(StandardPrincipalData::from(o))
+ }
+}
+
impl PrincipalData {
pub fn version(&self) -> u8 {
match self {
@@ -1285,7 +1369,7 @@ impl PrincipalData {
self.version() < 32
}
- pub fn parse(literal: &str) -> Result {
+ pub fn parse(literal: &str) -> Result {
// be permissive about leading single-quote
let literal = literal.strip_prefix('\'').unwrap_or(literal);
@@ -1296,22 +1380,23 @@ impl PrincipalData {
}
}
- pub fn parse_qualified_contract_principal(literal: &str) -> Result {
+ pub fn parse_qualified_contract_principal(literal: &str) -> Result {
let contract_id = QualifiedContractIdentifier::parse(literal)?;
Ok(PrincipalData::Contract(contract_id))
}
- pub fn parse_standard_principal(literal: &str) -> Result {
+ pub fn parse_standard_principal(literal: &str) -> Result {
let (version, data) = c32::c32_address_decode(literal)
- .map_err(|x| CodecError::ParseError(format!("Invalid principal literal: {x}")))?;
+ .map_err(|x| RuntimeErrorType::ParseError(format!("Invalid principal literal: {x}")))?;
if data.len() != 20 {
- return Err(CodecError::ParseError(
+ return Err(RuntimeErrorType::ParseError(
"Invalid principal literal: Expected 20 data bytes.".to_string(),
- ));
+ )
+ .into());
}
let mut fixed_data = [0; 20];
fixed_data.copy_from_slice(&data[..20]);
- StandardPrincipalData::new(version, fixed_data)
+ Ok(StandardPrincipalData::new(version, fixed_data)?)
}
}
@@ -1331,11 +1416,7 @@ impl fmt::Display for PrincipalData {
impl fmt::Display for CallableData {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if let Some(trait_identifier) = &self.trait_identifier {
- write!(
- f,
- "({} as <{}>)",
- self.contract_identifier, trait_identifier,
- )
+ write!(f, "({} as <{trait_identifier}>)", self.contract_identifier)
} else {
write!(f, "{}", self.contract_identifier,)
}
@@ -1429,7 +1510,7 @@ impl TupleData {
fn new(
type_signature: TupleTypeSignature,
data_map: BTreeMap,
- ) -> Result {
+ ) -> Result {
let t = TupleData {
type_signature,
data_map,
@@ -1449,7 +1530,7 @@ impl TupleData {
// TODO: add tests from mutation testing results #4833
#[cfg_attr(test, mutants::skip)]
- pub fn from_data(data: Vec<(ClarityName, Value)>) -> Result {
+ pub fn from_data(data: Vec<(ClarityName, Value)>) -> Result {
let mut type_map = BTreeMap::new();
let mut data_map = BTreeMap::new();
for (name, value) in data.into_iter() {
@@ -1457,9 +1538,7 @@ impl TupleData {
let entry = type_map.entry(name.clone());
match entry {
Entry::Vacant(e) => e.insert(type_info),
- Entry::Occupied(_) => {
- return Err(CodecError::NameAlreadyUsedInTuple(name.into()));
- }
+ Entry::Occupied(_) => return Err(CheckErrors::NameAlreadyUsed(name.into()).into()),
};
data_map.insert(name, value);
}
@@ -1473,33 +1552,33 @@ impl TupleData {
epoch: &StacksEpochId,
data: Vec<(ClarityName, Value)>,
expected: &TupleTypeSignature,
- ) -> Result {
+ ) -> Result {
let mut data_map = BTreeMap::new();
for (name, value) in data.into_iter() {
let expected_type = expected
.field_type(&name)
- .ok_or(CodecError::FailureConstructingTupleWithType)?;
+ .ok_or(InterpreterError::FailureConstructingTupleWithType)?;
if !expected_type.admits(epoch, &value)? {
- return Err(CodecError::FailureConstructingTupleWithType);
+ return Err(InterpreterError::FailureConstructingTupleWithType.into());
}
data_map.insert(name, value);
}
Self::new(expected.clone(), data_map)
}
- pub fn get(&self, name: &str) -> Result<&Value, CodecError> {
+ pub fn get(&self, name: &str) -> Result<&Value> {
self.data_map.get(name).ok_or_else(|| {
- CodecError::NoSuchTupleField(name.to_string(), self.type_signature.clone())
+ CheckErrors::NoSuchTupleField(name.to_string(), self.type_signature.clone()).into()
})
}
- pub fn get_owned(mut self, name: &str) -> Result {
+ pub fn get_owned(mut self, name: &str) -> Result {
self.data_map.remove(name).ok_or_else(|| {
- CodecError::NoSuchTupleField(name.to_string(), self.type_signature.clone())
+ CheckErrors::NoSuchTupleField(name.to_string(), self.type_signature.clone()).into()
})
}
- pub fn shallow_merge(mut base: TupleData, updates: TupleData) -> Result {
+ pub fn shallow_merge(mut base: TupleData, updates: TupleData) -> Result {
let TupleData {
data_map,
mut type_signature,
@@ -1517,7 +1596,7 @@ impl fmt::Display for TupleData {
write!(f, "(tuple")?;
for (name, value) in self.data_map.iter() {
write!(f, " ")?;
- write!(f, "({} {})", &**name, value)?;
+ write!(f, "({} {value})", &**name)?;
}
write!(f, ")")
}
@@ -1528,3 +1607,26 @@ impl fmt::Display for TupleData {
pub fn byte_len_of_serialization(serialized: &str) -> u64 {
serialized.len() as u64 / 2
}
+
+#[derive(Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)]
+pub struct FunctionIdentifier {
+ identifier: String,
+}
+
+impl fmt::Display for FunctionIdentifier {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}", self.identifier)
+ }
+}
+
+impl FunctionIdentifier {
+ pub fn new_native_function(name: &str) -> FunctionIdentifier {
+ let identifier = format!("_native_:{name}");
+ FunctionIdentifier { identifier }
+ }
+
+ pub fn new_user_function(name: &str, context: &str) -> FunctionIdentifier {
+ let identifier = format!("{context}:{name}");
+ FunctionIdentifier { identifier }
+ }
+}
diff --git a/clarity-serialization/src/types/serialization.rs b/clarity-serialization/src/types/serialization.rs
index 26da1988ab..2179efd824 100644
--- a/clarity-serialization/src/types/serialization.rs
+++ b/clarity-serialization/src/types/serialization.rs
@@ -14,7 +14,7 @@
// along with this program. If not, see .
use std::io::{Read, Write};
-use std::{cmp, str};
+use std::{cmp, error, str};
use lazy_static::lazy_static;
use stacks_common::codec::{Error as codec_error, StacksMessageCodec};
@@ -23,7 +23,7 @@ use stacks_common::util::hash::{hex_bytes, to_hex};
use stacks_common::util::retry::BoundReader;
use super::{ListTypeData, TupleTypeSignature};
-use crate::errors::CodecError;
+use crate::errors::{CheckErrors, IncomparableError, InterpreterError};
use crate::representations::{ClarityName, ContractName, MAX_STRING_LEN};
use crate::types::{
BOUND_VALUE_SERIALIZATION_BYTES, BufferLength, CallableData, CharType, MAX_TYPE_DEPTH,
@@ -31,6 +31,23 @@ use crate::types::{
SequenceSubtype, StandardPrincipalData, StringSubtype, TupleData, TypeSignature, Value,
};
+/// Errors that may occur in serialization or deserialization
+/// If deserialization failed because the described type is a bad type and
+/// a CheckError is thrown, it gets wrapped in BadTypeError.
+/// Any IOErrrors from the supplied buffer will manifest as IOError variants,
+/// except for EOF -- if the deserialization code experiences an EOF, it is caught
+/// and rethrown as DeserializationError
+#[derive(Debug, PartialEq)]
+pub enum SerializationError {
+ IOError(IncomparableError),
+ BadTypeError(CheckErrors),
+ DeserializationError(String),
+ DeserializeExpected(Box),
+ LeftoverBytesInDeserialization,
+ SerializationError(String),
+ UnexpectedSerialization,
+}
+
lazy_static! {
pub static ref NONE_SERIALIZATION_LEN: u64 = {
#[allow(clippy::unwrap_used)]
@@ -52,6 +69,65 @@ const SANITIZATION_READ_BOUND: u64 = 15_000_000;
/// clarity depth limit is supported.
const UNSANITIZED_DEPTH_CHECK: usize = 16;
+impl std::fmt::Display for SerializationError {
+ fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+ match self {
+ SerializationError::IOError(e) => {
+ write!(f, "Serialization error caused by IO: {}", e.err)
+ }
+ SerializationError::BadTypeError(e) => {
+ write!(f, "Deserialization error, bad type, caused by: {e}")
+ }
+ SerializationError::DeserializationError(e) => {
+ write!(f, "Deserialization error: {e}")
+ }
+ SerializationError::SerializationError(e) => {
+ write!(f, "Serialization error: {e}")
+ }
+ SerializationError::DeserializeExpected(e) => write!(
+ f,
+ "Deserialization expected the type of the input to be: {e}"
+ ),
+ SerializationError::UnexpectedSerialization => {
+ write!(f, "The serializer handled an input in an unexpected way")
+ }
+ SerializationError::LeftoverBytesInDeserialization => {
+ write!(f, "Deserialization error: bytes left over in buffer")
+ }
+ }
+ }
+}
+
+impl error::Error for SerializationError {
+ fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+ match self {
+ SerializationError::IOError(e) => Some(&e.err),
+ SerializationError::BadTypeError(e) => Some(e),
+ _ => None,
+ }
+ }
+}
+
+// Note: a byte stream that describes a longer type than
+// there are available bytes to read will result in an IOError(UnexpectedEOF)
+impl From for SerializationError {
+ fn from(err: std::io::Error) -> Self {
+ SerializationError::IOError(IncomparableError { err })
+ }
+}
+
+impl From<&str> for SerializationError {
+ fn from(e: &str) -> Self {
+ SerializationError::DeserializationError(e.into())
+ }
+}
+
+impl From for SerializationError {
+ fn from(e: CheckErrors) -> Self {
+ SerializationError::BadTypeError(e)
+ }
+}
+
define_u8_enum!(TypePrefix {
Int = 0,
UInt = 1,
@@ -121,7 +197,7 @@ impl From<&Value> for TypePrefix {
/// are repeatedly serialized or deserialized.
trait ClarityValueSerializable {
fn serialize_write(&self, w: &mut W) -> std::io::Result<()>;
- fn deserialize_read(r: &mut R) -> Result;
+ fn deserialize_read(r: &mut R) -> Result;
}
impl ClarityValueSerializable for StandardPrincipalData {
@@ -130,13 +206,13 @@ impl ClarityValueSerializable for StandardPrincipalData {
w.write_all(&self.1)
}
- fn deserialize_read(r: &mut R) -> Result {
+ fn deserialize_read(r: &mut R) -> Result {
let mut version = [0; 1];
let mut data = [0; 20];
r.read_exact(&mut version)?;
r.read_exact(&mut data)?;
StandardPrincipalData::new(version[0], data)
- .map_err(|_| CodecError::UnexpectedSerialization)
+ .map_err(|_| SerializationError::UnexpectedSerialization)
}
}
@@ -150,24 +226,22 @@ macro_rules! serialize_guarded_string {
w.write_all(self.as_str().as_bytes())
}
- fn deserialize_read(r: &mut R) -> Result