Merge remote-tracking branch 'upstream/develop' into feat/clarity-eval-hook-tracing-improvements

cylewitruk-stacks · cylewitruk-stacks · commit dd4e5830a192 · 2026-07-22T09:09:02.000+02:00
diff --git a/changelog.d/clarity-value-64-bytes.changed b/changelog.d/clarity-value-64-bytes.changed
@@ -0,0 +1 @@
+Shrunk `size_of::<Value>()` from 128 to 64 bytes by boxing `CallableData::trait_identifier`, halving the memory of every `Vec<Value>`, clone, and stack copy in the Clarity VM and deserializer.
diff --git a/clarity-types/src/tests/types/mod.rs b/clarity-types/src/tests/types/mod.rs
@@ -851,7 +851,7 @@ fn test_sequence_try_retain_utf8_keep_none() {
 
 #[test]
 fn test_sequence_try_retain_utf8_multibyte_filter() {
-    let dog = vec![0xF0, 0x9F, 0x90, 0xB6]; // 🐶 
+    let dog = vec![0xF0, 0x9F, 0x90, 0xB6]; // 🐶
     let cat = vec![0xF0, 0x9F, 0x90, 0xB1]; // 🐱
     let seq = SequenceData::String(CharType::UTF8(UTF8Data {
         data: vec![dog.clone(), cat.clone(), dog.clone()],
@@ -902,3 +902,11 @@ fn test_sequence_try_retain_internal_error() {
     let err = seq.try_retain::<(), _>(utils::keep_all).unwrap_err();
     assert!(matches!(err, RetainValuesError::Internal(_)));
 }
+
+/// Every `Vec<Value>` in the VM scales with this size; a variant growing past
+/// 64 bytes doubles list memory. Box large payloads instead.
+#[test]
+fn test_value_size_regression() {
+    // exact on 64-bit so any layout change must update this test deliberately;
+    assert_eq!(size_of::<Value>(), 64);
+}
diff --git a/clarity-types/src/tests/types/signatures.rs b/clarity-types/src/tests/types/signatures.rs
@@ -495,7 +495,7 @@ fn test_type_min_size_callable_trait_matches_minimum_value_kind() {
     let declared_type = TypeSignature::CallableType(CallableSubtype::Trait(trait_id.clone()));
     let min_value = Value::CallableContract(CallableData {
         contract_identifier: QualifiedContractIdentifier::local("a").unwrap(),
-        trait_identifier: Some(trait_id.clone()),
+        trait_identifier: Some(Box::new(trait_id.clone())),
     });
     let min_value_type = TypeSignature::type_of(&min_value).unwrap();
 
diff --git a/clarity-types/src/types/mod.rs b/clarity-types/src/types/mod.rs
@@ -244,7 +244,7 @@ pub struct ResponseData {
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CallableData {
     pub contract_identifier: QualifiedContractIdentifier,
-    pub trait_identifier: Option<TraitIdentifier>,
+    pub trait_identifier: Option<Box<TraitIdentifier>>,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize, PartialOrd, Ord)]
diff --git a/clarity-types/src/types/signatures.rs b/clarity-types/src/types/signatures.rs
@@ -1269,7 +1269,7 @@ impl TypeSignature {
             Value::Response(v) => v.type_signature()?,
             Value::CallableContract(v) => {
                 if let Some(trait_identifier) = &v.trait_identifier {
-                    CallableType(CallableSubtype::Trait(trait_identifier.clone()))
+                    CallableType(CallableSubtype::Trait(trait_identifier.as_ref().clone()))
                 } else {
                     CallableType(CallableSubtype::Principal(v.contract_identifier.clone()))
                 }
diff --git a/clarity/src/vm/callables.rs b/clarity/src/vm/callables.rs
@@ -262,7 +262,7 @@ impl DefinedFunction {
                             name.clone(),
                             CallableData {
                                 contract_identifier: callee_contract_id.clone(),
-                                trait_identifier: Some(trait_identifier.clone()),
+                                trait_identifier: Some(Box::new(trait_identifier.clone())),
                             },
                         );
                     }
@@ -278,7 +278,7 @@ impl DefinedFunction {
                             name.clone(),
                             CallableData {
                                 contract_identifier: callee_contract_id.clone(),
-                                trait_identifier: Some(trait_identifier.clone()),
+                                trait_identifier: Some(Box::new(trait_identifier.clone())),
                             },
                         );
                     }
@@ -563,7 +563,7 @@ fn clarity2_implicit_cast(
             Value::CallableContract(callable_data),
         ) => Value::CallableContract(CallableData {
             contract_identifier: callable_data.contract_identifier.clone(),
-            trait_identifier: Some(trait_identifier.clone()),
+            trait_identifier: Some(Box::new(trait_identifier.clone())),
         }),
         // N.B. it seems like this should be illegal, since it is converting a
         // principal to a callable trait, and only principal literals should be
@@ -578,7 +578,7 @@ fn clarity2_implicit_cast(
             Value::Principal(PrincipalData::Contract(contract_identifier)),
         ) => Value::CallableContract(CallableData {
             contract_identifier: contract_identifier.clone(),
-            trait_identifier: Some(trait_identifier.clone()),
+            trait_identifier: Some(Box::new(trait_identifier.clone())),
         }),
         _ => value.clone(),
     })
@@ -621,7 +621,10 @@ mod test {
         let cast_contract = clarity2_implicit_cast(&trait_ty, &contract).unwrap();
         let cast_trait = cast_contract.expect_callable().unwrap();
         assert_eq!(&cast_trait.contract_identifier, &contract_identifier);
-        assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
+        assert_eq!(
+            cast_trait.trait_identifier.unwrap().as_ref(),
+            &trait_identifier
+        );
 
         // (optional principal) -> (optional <trait>)
         let optional_ty = TypeSignature::new_option(trait_ty.clone()).unwrap();
@@ -633,7 +636,7 @@ mod test {
                 trait_identifier: trait_id,
             }) => {
                 assert_eq!(contract_id, &contract_identifier);
-                assert_eq!(trait_id.as_ref().unwrap(), &trait_identifier);
+                assert_eq!(trait_id.as_deref().unwrap(), &trait_identifier);
             }
             other => panic!("expected Value::CallableContract, got {other:?}"),
         }
@@ -649,7 +652,10 @@ mod test {
             .expect_callable()
             .unwrap();
         assert_eq!(&cast_trait.contract_identifier, &contract_identifier);
-        assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
+        assert_eq!(
+            cast_trait.trait_identifier.unwrap().as_ref(),
+            &trait_identifier
+        );
 
         // (err principal) -> (err <trait>)
         let response_err_ty =
@@ -662,7 +668,10 @@ mod test {
             .expect_callable()
             .unwrap();
         assert_eq!(&cast_trait.contract_identifier, &contract_identifier);
-        assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
+        assert_eq!(
+            cast_trait.trait_identifier.unwrap().as_ref(),
+            &trait_identifier
+        );
 
         // (list principal) -> (list <trait>)
         let list_ty = TypeSignature::list_of(trait_ty.clone(), 4).unwrap();
@@ -671,7 +680,10 @@ mod test {
         let items = cast_list.expect_list().unwrap();
         for item in items {
             let cast_trait = item.expect_callable().unwrap();
-            assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
+            assert_eq!(
+                cast_trait.trait_identifier.unwrap().as_ref(),
+                &trait_identifier
+            );
         }
 
         // {a: principal} -> {a: <trait>}
@@ -703,7 +715,10 @@ mod test {
             .expect_callable()
             .unwrap();
         assert_eq!(&cast_trait.contract_identifier, &contract_identifier);
-        assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
+        assert_eq!(
+            cast_trait.trait_identifier.unwrap().as_ref(),
+            &trait_identifier
+        );
 
         // (list (optional principal)) -> (list (optional <trait>))
         let list_opt_ty = TypeSignature::list_of(optional_ty.clone(), 4).unwrap();
@@ -718,7 +733,10 @@ mod test {
         for item in items {
             if let Some(cast_opt) = item.expect_optional().unwrap() {
                 let cast_trait = cast_opt.expect_callable().unwrap();
-                assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
+                assert_eq!(
+                    cast_trait.trait_identifier.unwrap().as_ref(),
+                    &trait_identifier
+                );
             }
         }
 
@@ -734,7 +752,10 @@ mod test {
         let items = cast_list.expect_list().unwrap();
         for item in items {
             let cast_trait = item.expect_result_ok().unwrap().expect_callable().unwrap();
-            assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
+            assert_eq!(
+                cast_trait.trait_identifier.unwrap().as_ref(),
+                &trait_identifier
+            );
         }
 
         // (list (response uint principal)) -> (list (response uint <trait>))
@@ -749,7 +770,10 @@ mod test {
         let items = cast_list.expect_list().unwrap();
         for item in items {
             let cast_trait = item.expect_result_err().unwrap().expect_callable().unwrap();
-            assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
+            assert_eq!(
+                cast_trait.trait_identifier.unwrap().as_ref(),
+                &trait_identifier
+            );
         }
 
         // (optional (list (response uint principal))) -> (optional (list (response uint <trait>)))
@@ -767,7 +791,10 @@ mod test {
         let items = inner.expect_list().unwrap();
         for item in items {
             let cast_trait = item.expect_result_err().unwrap().expect_callable().unwrap();
-            assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
+            assert_eq!(
+                cast_trait.trait_identifier.unwrap().as_ref(),
+                &trait_identifier
+            );
         }
 
         // (optional (optional principal)) -> (optional (optional <trait>))
@@ -790,7 +817,7 @@ mod test {
                 trait_identifier: trait_id,
             }) => {
                 assert_eq!(contract_id, &contract_identifier);
-                assert_eq!(trait_id.as_ref().unwrap(), &trait_identifier);
+                assert_eq!(trait_id.as_deref().unwrap(), &trait_identifier);
             }
             other => panic!("expected Value::CallableContract, got {other:?}"),
         }

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+Shrunk `size_of::<Value>()` from 128 to 64 bytes by boxing `CallableData::trait_identifier`, halving the memory of every `Vec<Value>`, clone, and stack copy in the Clarity VM and deserializer.
Original file line number	Diff line number	Diff line change
`@@ -244,7 +244,7 @@ pub struct ResponseData {`
`244`	`244`	`#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]`
`245`	`245`	`pub struct CallableData {`
`246`	`246`	`pub contract_identifier: QualifiedContractIdentifier,`
`247`		`- pub trait_identifier: Option<TraitIdentifier>,`
	`247`	`+ pub trait_identifier: Option<Box<TraitIdentifier>>,`
`248`	`248`	`}`
`249`	`249`
`250`	`250`	`#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize, PartialOrd, Ord)]`
Original file line number	Diff line number	Diff line change
`@@ -1269,7 +1269,7 @@ impl TypeSignature {`
`1269`	`1269`	`Value::Response(v) => v.type_signature()?,`
`1270`	`1270`	`Value::CallableContract(v) => {`
`1271`	`1271`	`if let Some(trait_identifier) = &v.trait_identifier {`
`1272`		`- CallableType(CallableSubtype::Trait(trait_identifier.clone()))`
	`1272`	`+ CallableType(CallableSubtype::Trait(trait_identifier.as_ref().clone()))`
`1273`	`1273`	`} else {`
`1274`	`1274`	`CallableType(CallableSubtype::Principal(v.contract_identifier.clone()))`
`1275`	`1275`	`}`