Implement spec shaking using dead code elimination and data section of wasm

soroban-sdk-macros/src/derive_enum.rs

@@ -9,7 +9,7 @@ use stellar_xdr::{
     ScSpecUdtUnionCaseVoidV0, ScSpecUdtUnionV0, StringM, VecM, WriteXdr, SCSYMBOL_LIMIT,
 };
 
-use crate::{doc::docs_from_attrs, map_type::map_type, DEFAULT_XDR_RW_LIMITS};
+use crate::{doc::docs_from_attrs, map_type::map_type, spec_marker, DEFAULT_XDR_RW_LIMITS};
 
 pub fn derive_type_enum(
     path: &Path,
@@ -30,14 +30,15 @@ pub fn derive_type_enum(
             format!("enum {} must have variants", enum_ident),
         ));
     }
-    let (spec_cases, case_name_str_lits, try_froms, try_intos, try_from_xdrs, into_xdrs): (
-        Vec<_>,
-        Vec<_>,
-        Vec<_>,
-        Vec<_>,
-        Vec<_>,
-        Vec<_>,
-    ) = variants
+    let (
+        spec_cases,
+        case_name_str_lits,
+        variant_field_types,
+        try_froms,
+        try_intos,
+        try_from_xdrs,
+        into_xdrs,
+    ): (Vec<_>, Vec<_>, Vec<Vec<_>>, Vec<_>, Vec<_>, Vec<_>, Vec<_>) = variants
         .iter()
         .enumerate()
         .map(|(case_num, variant)| {
@@ -75,6 +76,10 @@ pub fn derive_type_enum(
                 }
                 _ => {}
             }
+
+            // Collect field types for IncludeSpecMarker
+            let field_types: Vec<_> = variant.fields.iter().map(|f| &f.ty).collect();
+
             let is_unit_variant = variant.fields == Fields::Unit;
             if !is_unit_variant {
                 let VariantTokens {
@@ -97,6 +102,7 @@ pub fn derive_type_enum(
                 (
                     spec_case,
                     case_name_str_lit,
+                    field_types,
                     try_from,
                     try_into,
                     try_from_xdr,
@@ -121,6 +127,7 @@ pub fn derive_type_enum(
                 (
                     spec_case,
                     case_name_str_lit,
+                    field_types,
                     try_from,
                     try_into,
                     try_from_xdr,
@@ -136,15 +143,21 @@ pub fn derive_type_enum(
         return quote! { #(#compile_errors)* };
     }
 
-    // Generated code spec.
-    let spec_gen = if spec {
+    // Compute spec XDR once if spec is enabled.
+    let spec_xdr = if spec {
         let spec_entry = ScSpecEntry::UdtUnionV0(ScSpecUdtUnionV0 {
             doc: docs_from_attrs(attrs),
             lib: lib.as_deref().unwrap_or_default().try_into().unwrap(),
             name: enum_ident.to_string().try_into().unwrap(),
             cases: spec_cases.try_into().unwrap(),
         });
-        let spec_xdr = spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap();
+        Some(spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap())
+    } else {
+        None
+    };
+
+    // Generated code spec.
+    let spec_gen = if let Some(ref spec_xdr) = spec_xdr {
         let spec_xdr_lit = proc_macro2::Literal::byte_string(spec_xdr.as_slice());
         let spec_xdr_len = spec_xdr.len();
         let spec_ident = format_ident!("__SPEC_XDR_TYPE_{}", enum_ident.to_string().to_uppercase());
@@ -162,10 +175,46 @@ pub fn derive_type_enum(
         None
     };
 
+    // IncludeSpecMarker impl - only generated when spec is true.
+    // Types with export=false should not be used at external boundaries.
+    let include_spec_impl = if let Some(ref spec_xdr) = spec_xdr {
+        // Create a marker that identifies this spec entry. The marker is a byte array
+        // in the data section with a distinctive pattern: "SpEc" + truncated SHA256.
+        // Post-build tools can scan the data section for "SpEc" markers and match
+        // against specs in contractspecv0.
+        let marker = spec_marker::spec_marker(spec_xdr);
+        let marker_lit = proc_macro2::Literal::byte_string(&marker);
+        let marker_len = marker.len();
+        // Flatten all variant field types for include_spec_marker calls
+        let all_field_types: Vec<_> = variant_field_types.iter().flatten().collect();
+        Some(quote! {
+            impl #path::IncludeSpecMarker for #enum_ident {
+                #[doc(hidden)]
+                #[inline(always)]
+                fn include_spec_marker() {
+                    // Include markers for nested variant field types.
+                    #(<#all_field_types as #path::IncludeSpecMarker>::include_spec_marker();)*
+                    #[cfg(target_family = "wasm")]
+                    {
+                        // Marker in data section. Post-build tools can scan for "SpEc"
+                        // patterns and match against specs in contractspecv0.
+                        static MARKER: [u8; #marker_len] = *#marker_lit;
+                        // Volatile read prevents DCE within live function.
+                        let _ = unsafe { ::core::ptr::read_volatile(MARKER.as_ptr()) };
+                    }
+                }
+            }
+        })
+    } else {
+        None
+    };
+
     // Output.
     let mut output = quote! {
         #spec_gen
 
+        #include_spec_impl
+
         impl #path::TryFromVal<#path::Env, #path::Val> for #enum_ident {
             type Error = #path::ConversionError;
             #[inline(always)]

soroban-sdk-macros/src/derive_enum_int.rs

@@ -7,7 +7,7 @@ use syn::{spanned::Spanned, Attribute, DataEnum, Error, ExprLit, Ident, Lit, Pat
 
 use stellar_xdr::{ScSpecEntry, ScSpecUdtEnumCaseV0, WriteXdr};
 
-use crate::{doc::docs_from_attrs, DEFAULT_XDR_RW_LIMITS};
+use crate::{doc::docs_from_attrs, spec_marker, DEFAULT_XDR_RW_LIMITS};
 
 // TODO: Add conversions to/from ScVal types.
 
@@ -65,15 +65,21 @@ pub fn derive_type_enum_int(
         return quote! { #(#compile_errors)* };
     }
 
-    // Generated code spec.
-    let spec_gen = if spec {
+    // Compute spec XDR once if spec is enabled.
+    let spec_xdr = if spec {
         let spec_entry = ScSpecEntry::UdtEnumV0(ScSpecUdtEnumV0 {
             doc: docs_from_attrs(attrs),
             lib: lib.as_deref().unwrap_or_default().try_into().unwrap(),
             name: enum_ident.to_string().try_into().unwrap(),
             cases: spec_cases.try_into().unwrap(),
         });
-        let spec_xdr = spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap();
+        Some(spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap())
+    } else {
+        None
+    };
+
+    // Generated code spec.
+    let spec_gen = if let Some(ref spec_xdr) = spec_xdr {
         let spec_xdr_lit = proc_macro2::Literal::byte_string(spec_xdr.as_slice());
         let spec_xdr_len = spec_xdr.len();
         let spec_ident = format_ident!("__SPEC_XDR_TYPE_{}", enum_ident.to_string().to_uppercase());
@@ -91,10 +97,42 @@ pub fn derive_type_enum_int(
         None
     };
 
+    // IncludeSpecMarker impl - only generated when spec is true.
+    // Types with export=false should not be used at external boundaries.
+    let include_spec_impl = if let Some(ref spec_xdr) = spec_xdr {
+        // Create a marker that identifies this spec entry. The marker is a byte array
+        // in the data section with a distinctive pattern: "SpEc" + truncated SHA256.
+        // Post-build tools can scan the data section for "SpEc" markers and match
+        // against specs in contractspecv0.
+        let marker = spec_marker::spec_marker(spec_xdr);
+        let marker_lit = proc_macro2::Literal::byte_string(&marker);
+        let marker_len = marker.len();
+        Some(quote! {
+            impl #path::IncludeSpecMarker for #enum_ident {
+                #[doc(hidden)]
+                #[inline(always)]
+                fn include_spec_marker() {
+                    #[cfg(target_family = "wasm")]
+                    {
+                        // Marker in data section. Post-build tools can scan for "SpEc"
+                        // patterns and match against specs in contractspecv0.
+                        static MARKER: [u8; #marker_len] = *#marker_lit;
+                        // Volatile read prevents DCE within live function.
+                        let _ = unsafe { ::core::ptr::read_volatile(MARKER.as_ptr()) };
+                    }
+                }
+            }
+        })
+    } else {
+        None
+    };
+
     // Output.
     let mut output = quote! {
         #spec_gen
 
+        #include_spec_impl
+
         impl #path::TryFromVal<#path::Env, #path::Val> for #enum_ident {
             type Error = #path::ConversionError;
             #[inline(always)]

soroban-sdk-macros/src/derive_error_enum_int.rs

@@ -5,7 +5,7 @@ use stellar_xdr::curr as stellar_xdr;
 use stellar_xdr::{ScSpecEntry, ScSpecUdtErrorEnumCaseV0, ScSpecUdtErrorEnumV0, StringM, WriteXdr};
 use syn::{spanned::Spanned, Attribute, DataEnum, Error, ExprLit, Ident, Lit, Path};
 
-use crate::{doc::docs_from_attrs, DEFAULT_XDR_RW_LIMITS};
+use crate::{doc::docs_from_attrs, spec_marker, DEFAULT_XDR_RW_LIMITS};
 
 pub fn derive_type_error_enum_int(
     path: &Path,
@@ -63,15 +63,21 @@ pub fn derive_type_error_enum_int(
         return quote! { #(#compile_errors)* };
     }
 
-    // Generated code spec.
-    let spec_gen = if spec {
+    // Compute spec XDR once if spec is enabled.
+    let spec_xdr = if spec {
         let spec_entry = ScSpecEntry::UdtErrorEnumV0(ScSpecUdtErrorEnumV0 {
             doc: docs_from_attrs(attrs),
             lib: lib.as_deref().unwrap_or_default().try_into().unwrap(),
             name: enum_ident.to_string().try_into().unwrap(),
             cases: spec_cases.try_into().unwrap(),
         });
-        let spec_xdr = spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap();
+        Some(spec_entry.to_xdr(DEFAULT_XDR_RW_LIMITS).unwrap())
+    } else {
+        None
+    };
+
+    // Generated code spec.
+    let spec_gen = if let Some(ref spec_xdr) = spec_xdr {
         let spec_xdr_lit = proc_macro2::Literal::byte_string(spec_xdr.as_slice());
         let spec_xdr_len = spec_xdr.len();
         let spec_ident = format_ident!("__SPEC_XDR_TYPE_{}", enum_ident.to_string().to_uppercase());
@@ -89,10 +95,42 @@ pub fn derive_type_error_enum_int(
         None
     };
 
+    // IncludeSpecMarker impl - only generated when spec is true.
+    // Types with export=false should not be used at external boundaries.
+    let include_spec_impl = if let Some(ref spec_xdr) = spec_xdr {
+        // Create a marker that identifies this spec entry. The marker is a byte array
+        // in the data section with a distinctive pattern: "SpEc" + truncated SHA256.
+        // Post-build tools can scan the data section for "SpEc" markers and match
+        // against specs in contractspecv0.
+        let marker = spec_marker::spec_marker(spec_xdr);
+        let marker_lit = proc_macro2::Literal::byte_string(&marker);
+        let marker_len = marker.len();
+        Some(quote! {
+            impl #path::IncludeSpecMarker for #enum_ident {
+                #[doc(hidden)]
+                #[inline(always)]
+                fn include_spec_marker() {
+                    #[cfg(target_family = "wasm")]
+                    {
+                        // Marker in data section. Post-build tools can scan for "SpEc"
+                        // patterns and match against specs in contractspecv0.
+                        static MARKER: [u8; #marker_len] = *#marker_lit;
+                        // Volatile read prevents DCE within live function.
+                        let _ = unsafe { ::core::ptr::read_volatile(MARKER.as_ptr()) };
+                    }
+                }
+            }
+        })
+    } else {
+        None
+    };
+
     // Output.
     quote! {
         #spec_gen
 
+        #include_spec_impl
+
         impl TryFrom<#path::Error> for #enum_ident {
             type Error = #path::Error;
             #[inline(always)]