fix(tx-macro): correctly generate uppercase aliases (#3053)

* fix: correctly generate uppercase aliases

* clippy

Author: klkvr

crates/tx-macros/Cargo.toml

@@ -31,13 +31,8 @@ quote = "1.0"
 proc-macro2 = "1.0"
 darling = "0.21"
 
-alloy-primitives.workspace = true
-
 [features]
-arbitrary = [
-	"alloy-primitives/arbitrary"
-]
+arbitrary = []
 serde = [
-	"alloy-primitives/serde",
 	"darling/serde"
 ]

crates/tx-macros/src/expand.rs

@@ -1,5 +1,4 @@
 use crate::parse::{GroupedVariants, VariantKind};
-use alloy_primitives::U8;
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
 use syn::{Ident, Path};
@@ -811,25 +810,12 @@ impl Expander {
             .iter()
             .map(|v| {
                 let name = &v.name;
-                let VariantKind::Typed(ty_value) = v.kind else { unreachable!() };
-
-                let tx_type = U8::from(ty_value);
-                let rename = format!("0x{tx_type:x}");
-
-                let mut aliases = vec![];
-                // Add alias for single digit hex values (e.g., "0x0" for "0x00")
-                if rename.len() == 3 {
-                    aliases.push(format!("0x0{}", rename.chars().last().unwrap()));
-                }
-
-                // Add alias for uppercase values (e.g., "0x7E" for "0x7e")
-                if rename != rename.to_uppercase() {
-                    aliases.push(rename.to_uppercase());
-                }
 
                 // Custom type or extract from wrapper
                 let inner_type = v.inner_type();
 
+                let (rename, aliases) = v.kind.serde_tag_and_aliases();
+
                 quote! {
                     #[serde(rename = #rename, #(alias = #aliases,)*)]
                     #name(#inner_type)

crates/tx-macros/src/parse.rs

@@ -73,6 +73,28 @@ pub(crate) enum VariantKind {
     Flattened,
 }
 
+impl VariantKind {
+    /// Returns serde transaction enum tag and aliases.
+    pub(crate) fn serde_tag_and_aliases(&self) -> (String, Vec<String>) {
+        let Self::Typed(ty) = self else { return Default::default() };
+
+        let tx_type_hex = format!("{ty:x}");
+
+        let mut aliases = vec![];
+        // Add alias for single digit hex values (e.g., "0x0" for "0x00")
+        if tx_type_hex.len() == 1 {
+            aliases.push(format!("0x0{}", tx_type_hex));
+        }
+
+        // Add alias for uppercase values (e.g., "0x7E" for "0x7e")
+        if tx_type_hex != tx_type_hex.to_uppercase() {
+            aliases.push(format!("0x{}", tx_type_hex.to_uppercase()));
+        }
+
+        (format!("0x{tx_type_hex}"), aliases)
+    }
+}
+
 /// Processed variant information.
 #[derive(Debug, Clone)]
 pub(crate) struct ProcessedVariant {
@@ -218,3 +240,24 @@ impl GroupedVariants {
         self.all.iter().map(|v| &v.ty).collect()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn serde_tag() {
+        assert_eq!(
+            VariantKind::Typed(126).serde_tag_and_aliases(),
+            ("0x7e".to_string(), vec!["0x7E".to_string()])
+        );
+        assert_eq!(
+            VariantKind::Typed(1).serde_tag_and_aliases(),
+            ("0x1".to_string(), vec!["0x01".to_string()])
+        );
+        assert_eq!(
+            VariantKind::Typed(10).serde_tag_and_aliases(),
+            ("0xa".to_string(), vec!["0x0a".to_string(), "0xA".to_string()])
+        );
+    }
+}

crates/tx-macros/src/serde.rs

@@ -1,5 +1,4 @@
-use crate::parse::{GroupedVariants, ProcessedVariant, VariantKind};
-use alloy_primitives::U8;
+use crate::parse::{GroupedVariants, ProcessedVariant};
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{Ident, Path};
@@ -87,44 +86,28 @@ impl<'a> SerdeGenerator<'a> {
         self.variants
             .typed
             .iter()
-            .filter_map(|v| {
+            .map(|v| {
                 let ProcessedVariant { name, ty, kind, serde_attrs, typed: _, doc_attrs: _ } = v;
 
-                if let VariantKind::Typed(tx_type) = kind {
-                    let tx_type = U8::from(*tx_type);
-                    let rename = format!("0x{tx_type:x}");
+                let (rename, aliases) = kind.serde_tag_and_aliases();
 
-                    let mut aliases = vec![];
-                    // Add alias for single digit hex values (e.g., "0x0" for "0x00")
-                    if rename.len() == 3 {
-                        aliases.push(format!("0x0{}", rename.chars().last().unwrap()));
+                // Special handling for legacy transactions
+                let maybe_with = if v.is_legacy() {
+                    let alloy_consensus = &self.alloy_consensus;
+                    let path = quote! {
+                        #alloy_consensus::transaction::signed_legacy_serde
                     }
+                    .to_string();
+                    quote! { with = #path, }
+                } else {
+                    quote! {}
+                };
 
-                    // Add alias for uppercase values (e.g., "0x7E" for "0x7e")
-                    if rename != rename.to_uppercase() {
-                        aliases.push(rename.to_uppercase());
-                    }
+                let maybe_other = serde_attrs.clone().unwrap_or_default();
 
-                    // Special handling for legacy transactions
-                    let maybe_with = if v.is_legacy() {
-                        let alloy_consensus = &self.alloy_consensus;
-                        let path = quote! {
-                            #alloy_consensus::transaction::signed_legacy_serde
-                        }
-                        .to_string();
-                        quote! { with = #path, }
-                    } else {
-                        quote! {}
-                    };
-
-                    let maybe_other = serde_attrs.clone().unwrap_or_default();
-
-                    Some(quote! {
-                        #[serde(rename = #rename, #(alias = #aliases,)* #maybe_with #maybe_other)]
-                        #name(#ty)
-                    })
-                } else {
-                    None
+                quote! {
+                    #[serde(rename = #rename, #(alias = #aliases,)* #maybe_with #maybe_other)]
+                    #name(#ty)
                 }
             })
             .collect()