feat: use clarity-serialization in clarity

clarity-serialization/src/types/mod.rs

@@ -25,6 +25,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::{
@@ -122,6 +124,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,
@@ -178,6 +197,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),
@@ -1268,6 +1294,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 {

clarity/Cargo.toml

@@ -18,6 +18,7 @@ name = "clarity"
 path = "./src/libclarity.rs"
 
 [dependencies]
+clarity-serialization = { package = "clarity-serialization", path = "../clarity-serialization", default-features = false }
 serde = "1"
 serde_derive = "1"
 regex = "1"
@@ -27,7 +28,6 @@ slog = { version = "2.5.2", features = [ "max_level_trace" ] }
 stacks_common = { package = "stacks-common", path = "../stacks-common", default-features = false }
 rstest = { version = "0.17.0", optional = true }
 rstest_reuse = { version = "0.5.0", optional = true }
-hashbrown = { workspace = true }
 rusqlite = { workspace = true, optional = true }
 
 [dependencies.serde_json]
@@ -39,6 +39,8 @@ assert-json-diff = "1.0.0"
 mutants = "0.0.3"
 rstest = { version = "0.17.0" }
 rstest_reuse = { version = "0.5.0" }
+clarity-serialization = { package = "clarity-serialization", path = "../clarity-serialization", default-features = false, features = ["testing"] }
+
 # a nightly rustc regression (35dbef235 2021-03-02) prevents criterion from compiling
 #  but it isn't necessary for tests: only benchmarks. therefore, commenting out for now.
 # criterion = "0.3"
@@ -51,8 +53,8 @@ default = ["rusqlite"]
 developer-mode = ["stacks_common/developer-mode"]
 slog_json = ["stacks_common/slog_json"]
 rusqlite = ["stacks_common/rusqlite", "dep:rusqlite"]
-testing = ["rstest", "rstest_reuse"]
+testing = ["rstest", "rstest_reuse", "clarity-serialization/testing"]
 devtools = []
 rollback_value_check = []
 disable-costs = []
-wasm-web = ["stacks_common/wasm-web"]
+wasm-web = ["stacks_common/wasm-web", "clarity-serialization/wasm-web"]

clarity/src/vm/analysis/analysis_db.rs

@@ -16,16 +16,17 @@
 
 use std::collections::{BTreeMap, BTreeSet};
 
+use clarity_serialization::representations::ClarityName;
+use clarity_serialization::types::{QualifiedContractIdentifier, TraitIdentifier};
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::analysis::errors::{CheckErrors, CheckResult};
 use crate::vm::analysis::type_checker::ContractAnalysis;
 use crate::vm::database::{
     ClarityBackingStore, ClarityDeserializable, ClaritySerializable, RollbackWrapper,
 };
-use crate::vm::representations::ClarityName;
 use crate::vm::types::signatures::FunctionSignature;
-use crate::vm::types::{FunctionType, QualifiedContractIdentifier, TraitIdentifier};
+use crate::vm::types::FunctionType;
 use crate::vm::ClarityVersion;
 
 pub struct AnalysisDatabase<'a> {

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

@@ -14,16 +14,18 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+use clarity_serialization::representations::ClarityName;
+
 pub use super::errors::{
     check_argument_count, check_arguments_at_least, CheckError, CheckErrors, CheckResult,
 };
 use crate::vm::analysis::types::ContractAnalysis;
 use crate::vm::functions::define::{DefineFunctions, DefineFunctionsParsed};
 use crate::vm::functions::NativeFunctions;
+use crate::vm::representations::SymbolicExpression;
 use crate::vm::representations::SymbolicExpressionType::{
     Atom, AtomValue, Field, List, LiteralValue, TraitReference,
 };
-use crate::vm::representations::{ClarityName, SymbolicExpression};
 use crate::vm::variables::NativeVariables;
 use crate::vm::ClarityVersion;
 

clarity/src/vm/analysis/errors.rs

@@ -16,10 +16,12 @@
 
 use std::{error, fmt};
 
+use clarity_serialization::errors::CodecError;
+use clarity_serialization::types::{TraitIdentifier, TupleTypeSignature, TypeSignature, Value};
+
 use crate::vm::costs::{CostErrors, ExecutionCost};
 use crate::vm::diagnostic::{DiagnosableError, Diagnostic};
 use crate::vm::representations::SymbolicExpression;
-use crate::vm::types::{TraitIdentifier, TupleTypeSignature, TypeSignature, Value};
 
 pub type CheckResult<T> = Result<T, CheckError>;
 
@@ -493,3 +495,52 @@ impl DiagnosableError for CheckErrors {
         }
     }
 }
+
+impl From<CodecError> for CheckErrors {
+    fn from(err: CodecError) -> Self {
+        match err {
+            CodecError::ValueTooLarge => CheckErrors::ValueTooLarge,
+            CodecError::ValueOutOfBounds => CheckErrors::ValueOutOfBounds,
+            CodecError::TypeSignatureTooDeep => CheckErrors::TypeSignatureTooDeep,
+            CodecError::SupertypeTooLarge => CheckErrors::SupertypeTooLarge,
+            CodecError::EmptyTuplesNotAllowed => CheckErrors::EmptyTuplesNotAllowed,
+            CodecError::ListTypesMustMatch => CheckErrors::ListTypesMustMatch,
+            CodecError::CouldNotDetermineType => CheckErrors::CouldNotDetermineType,
+            CodecError::CouldNotDetermineSerializationType => {
+                CheckErrors::CouldNotDetermineSerializationType
+            }
+            CodecError::InvalidStringCharacters => CheckErrors::InvalidCharactersDetected,
+            CodecError::InvalidUtf8Encoding => CheckErrors::InvalidUTF8Encoding,
+            CodecError::NoSuchTupleField(name, sig) => CheckErrors::NoSuchTupleField(name, sig),
+            CodecError::TypeError { expected, found } => CheckErrors::TypeError(*expected, *found),
+            CodecError::TypeValueError { expected, found } => {
+                CheckErrors::TypeValueError(*expected, *found)
+            }
+            CodecError::Expect(s) => CheckErrors::Expects(s),
+            // These errors don't have a match in CheckErrors, so we convert
+            // them to a descriptive string inside the `Expects` variant.
+            // Based on the current code, this should never happen.
+            CodecError::Io(_)
+            | CodecError::Serialization(_)
+            | CodecError::Deserialization(_)
+            | CodecError::DeserializeExpected(_)
+            | CodecError::UnexpectedSerialization
+            | CodecError::LeftoverBytesInDeserialization
+            | CodecError::ParseError(_)
+            | CodecError::BadTypeConstruction
+            | CodecError::FailureConstructingTupleWithType
+            | CodecError::FailureConstructingListWithType
+            | CodecError::NameAlreadyUsedInTuple(_)
+            | CodecError::InvalidClarityName(_, _)
+            | CodecError::InvalidContractName(_, _) => {
+                CheckErrors::Expects(format!("Unexpected error: {err:?}"))
+            }
+        }
+    }
+}
+
+impl From<CodecError> for CheckError {
+    fn from(err: CodecError) -> Self {
+        CheckError::new(err.into())
+    }
+}

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

@@ -14,7 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use hashbrown::HashMap;
+use std::collections::HashMap;
+
+use clarity_serialization::representations::ClarityName;
+use clarity_serialization::types::{PrincipalData, Value};
 use stacks_common::types::StacksEpochId;
 
 pub use super::errors::{
@@ -27,8 +30,7 @@ use crate::vm::functions::NativeFunctions;
 use crate::vm::representations::SymbolicExpressionType::{
     Atom, AtomValue, Field, List, LiteralValue, TraitReference,
 };
-use crate::vm::representations::{ClarityName, SymbolicExpression, SymbolicExpressionType};
-use crate::vm::types::{PrincipalData, Value};
+use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType};
 use crate::vm::ClarityVersion;
 
 #[cfg(test)]

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

@@ -14,9 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 
-use hashbrown::HashMap;
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult};

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

@@ -14,9 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::BTreeMap;
-
-use hashbrown::{HashMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet};
 
 use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult};
 use crate::vm::analysis::types::ContractAnalysis;

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

@@ -41,7 +41,7 @@ use crate::vm::representations::SymbolicExpressionType::{
     Atom, AtomValue, Field, List, LiteralValue, TraitReference,
 };
 use crate::vm::representations::{depth_traverse, ClarityName, SymbolicExpression};
-use crate::vm::types::signatures::FunctionSignature;
+use crate::vm::types::signatures::{FunctionSignature, TypeSignatureExt as _};
 use crate::vm::types::{
     parse_name_type_pairs, FixedFunction, FunctionArg, FunctionType, PrincipalData,
     QualifiedContractIdentifier, TypeSignature, Value,

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

@@ -58,9 +58,8 @@ fn check_special_list_cons(
             type_arg.type_size()?,
         )?;
     }
-    TypeSignature::parent_list_type(&typed_args)
-        .map_err(|x| x.into())
-        .map(TypeSignature::from)
+    let list_type = TypeSignature::parent_list_type(&typed_args).map_err(CheckError::from)?;
+    Ok(TypeSignature::from(list_type))
 }
 
 fn check_special_print(

clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs

@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+use clarity_serialization::representations::ClarityName;
+use clarity_serialization::types::TypeSignature;
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::analysis::type_checker::v2_05::{
@@ -22,8 +24,7 @@ use crate::vm::analysis::type_checker::v2_05::{
 };
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::{analysis_typecheck_cost, runtime_cost};
-use crate::vm::representations::{ClarityName, SymbolicExpression};
-use crate::vm::types::TypeSignature;
+use crate::vm::representations::SymbolicExpression;
 
 pub fn check_special_okay(
     checker: &mut TypeChecker,

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

@@ -25,7 +25,8 @@ use crate::vm::types::SequenceSubtype::*;
 use crate::vm::types::StringSubtype::*;
 use crate::vm::types::TypeSignature::{BoolType, IntType, PrincipalType, UIntType};
 use crate::vm::types::{
-    FixedFunction, FunctionType, QualifiedContractIdentifier, TypeSignature, BUFF_32, BUFF_64,
+    FixedFunction, FunctionType, QualifiedContractIdentifier, TypeSignature, TypeSignatureExt as _,
+    BUFF_32, BUFF_64,
 };
 use crate::vm::ClarityVersion;
 
@@ -1293,7 +1294,7 @@ fn test_high_order_map() {
 fn test_function_order_tuples() {
     let snippet = "
 (define-read-only (get-score)
-    (ok 
+    (ok
         (tuple
             (score (get-zero))
         )

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

@@ -14,9 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::BTreeMap;
-
-use hashbrown::{HashMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet};
 
 use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult};
 use crate::vm::analysis::type_checker::is_reserved_word;

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

@@ -49,7 +49,7 @@ use crate::vm::types::{
     parse_name_type_pairs, FixedFunction, FunctionArg, FunctionType, ListData, ListTypeData,
     OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, SequenceData,
     SequenceSubtype, StringSubtype, TraitIdentifier, TupleData, TupleTypeSignature, TypeSignature,
-    Value, MAX_TYPE_DEPTH,
+    TypeSignatureExt as _, Value, MAX_TYPE_DEPTH,
 };
 use crate::vm::variables::NativeVariables;
 use crate::vm::ClarityVersion;

clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs

@@ -4,7 +4,7 @@ use super::{TypeChecker, TypeResult};
 use crate::vm::analysis::read_only_checker::check_argument_count;
 use crate::vm::analysis::type_checker::contexts::TypingContext;
 use crate::vm::analysis::CheckError;
-use crate::vm::types::{BufferLength, SequenceSubtype, TypeSignature};
+use crate::vm::types::{BufferLength, SequenceSubtype, TypeSignature, TypeSignatureExt as _};
 use crate::vm::SymbolicExpression;
 
 /// `to-consensus-buff?` admits exactly one argument:

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

@@ -65,14 +65,17 @@ fn check_special_list_cons(
     for arg in args.iter() {
         // don't use map here, since type_check has side-effects.
         let checked = checker.type_check(arg, context)?;
-        let cost = checked.type_size().and_then(|ty_size| {
-            checker
-                .compute_cost(
-                    ClarityCostFunction::AnalysisListItemsCheck,
-                    &[ty_size.into()],
-                )
-                .map_err(CheckErrors::from)
-        });
+        let cost = checked
+            .type_size()
+            .map_err(CheckErrors::from)
+            .and_then(|ty_size| {
+                checker
+                    .compute_cost(
+                        ClarityCostFunction::AnalysisListItemsCheck,
+                        &[ty_size.into()],
+                    )
+                    .map_err(CheckErrors::from)
+            });
         costs.push(cost);
 
         if let Some(cur_size) = entries_size {

clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs

@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+use clarity_serialization::representations::ClarityName;
+use clarity_serialization::types::TypeSignature;
 use stacks_common::types::StacksEpochId;
 
 use super::{
@@ -22,8 +24,7 @@ use super::{
 use crate::vm::analysis::type_checker::contexts::TypingContext;
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::{analysis_typecheck_cost, runtime_cost, CostErrors, CostTracker};
-use crate::vm::representations::{ClarityName, SymbolicExpression};
-use crate::vm::types::TypeSignature;
+use crate::vm::representations::SymbolicExpression;
 
 pub fn check_special_okay(
     checker: &mut TypeChecker,