Merge pull request #6310 from Jiloc/feat/clarity-depend-on-clarity-serialization

feat: use `clarity-serialization` in `clarity`

Author: Jiloc

.github/workflows/cargo-hack-check.yml

@@ -91,11 +91,12 @@ jobs:
       - name: Run cargo hack check (WASM Web)
         run: |
           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: Run cargo hack check (WASM Deterministic)
@@ -108,9 +109,6 @@ jobs:
             --include-features=wasm-deterministic,slog_json \
             --features=wasm-deterministic
 
-      - name: Run cargo hack check
-        run: ${{ matrix.command }}
-
   fuzz-targets:
     name: Fuzz targets (nightly)
     runs-on: ubuntu-latest

Cargo.lock

@@ -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"]

clarity-serialization/Cargo.toml

@@ -21,17 +21,15 @@ This crate provides the core components for working with Clarity data structures
 This example demonstrates how to construct a complex Clarity `(tuple)` and serialize it to its hexadecimal string representation, which is suitable for use as a transaction argument.
 
 ```rust
-use clarity_serialization::types::{Value, TupleData, PrincipalData};
+use clarity_serialization::types::{PrincipalData, TupleData, Value};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // 1. Construct the individual values that will go into our tuple.
     let id = Value::UInt(101);
-    let owner = Value::Principal(
-        PrincipalData::parse("SM2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQVX8X0G")?
-    );
-    let metadata = Value::some(
-        Value::buff_from(vec![0xde, 0xad, 0xbe, 0xef])?
-    )?;
+    let owner = Value::Principal(PrincipalData::parse(
+        "SM2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQVX8X0G",
+    )?);
+    let metadata = Value::some(Value::buff_from(vec![0xde, 0xad, 0xbe, 0xef])?)?;
 
     // 2. Create a vec of name-value pairs for the tuple.
     let tuple_fields = vec![
@@ -44,7 +42,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let my_tuple = Value::from(TupleData::from_data(tuple_fields)?);
 
     // 4. Serialize the tuple to its consensus-cricital hex string.
-    let hex_string = my_tuple.serialize_to_hex()?;
+    let hex_string = my_tuple
+        .serialize_to_hex()
+        .map_err(|e| format!("Error serializing tuple to hex: {e:?}"))?;
 
     println!("Clarity Tuple: {my_tuple}");
     println!("Serialized Hex: {hex_string}");
@@ -64,7 +64,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 This example shows the reverse process: taking a hex string and deserializing it into a structured `Value` object, while validating it against an expected type.
 
 ```rust
-use clarity_serialization::types::{Value, TypeSignature};
+use clarity_serialization::types::{TypeSignature, Value};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let hex_string = "0c000000030269640100000000000000000000000000000065086d657461646174610a0200000004deadbeef056f776e65720514a46ff88886c2ef9762d970b4d2c63678835bd39d";

clarity-serialization/README.md

@@ -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 <http://www.gnu.org/licenses/>.
+
+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<String>;
+    fn level(&self) -> Level {
+        Level::Error
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct Diagnostic {
+    pub level: Level,
+    pub message: String,
+    pub spans: Vec<Span>,
+    pub suggestion: Option<String>,
+}
+
+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<String> = 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)
+    }
+}