introduce StableAbi extension to frozen-abi

Author: puhtaytow

Cargo.lock

@@ -32,7 +32,7 @@ members = [
     "fee-structure",
     "file-download",
     "frozen-abi",
-    "frozen-abi-macro",
+    "frozen-abi-macro", "frozen-abi-test",
     "genesis-config",
     "hard-forks",
     "hash",

Cargo.toml

@@ -23,6 +23,42 @@ pub fn derive_abi_enum_visitor(_item: TokenStream) -> TokenStream {
     "".parse().unwrap()
 }
 
+#[cfg(not(feature = "frozen-abi"))]
+#[proc_macro_derive(StableAbi)]
+pub fn derive_stable_abi(_item: TokenStream) -> TokenStream {
+    "".parse().unwrap()
+}
+
+#[cfg(feature = "frozen-abi")]
+#[proc_macro_derive(StableAbi)]
+pub fn derive_stable_abi(item: TokenStream) -> TokenStream {
+    use quote::quote;
+    use syn::{parse_macro_input, Error, Item};
+
+    let item = parse_macro_input!(item as Item);
+
+    let ident = match item {
+        Item::Struct(ref s) => &s.ident,
+        Item::Enum(ref e) => &e.ident,
+        Item::Type(ref t) => &t.ident,
+        _ => {
+            return Error::new_spanned(
+                item,
+                "StableAbi can only be derived for struct, enum, or type alias",
+            )
+            .to_compile_error()
+            .into();
+        }
+    };
+
+    let expanded = quote! {
+        #[automatically_derived]
+        impl ::solana_frozen_abi::stable_abi::StableAbi for #ident {}
+    };
+
+    expanded.into()
+}
+
 #[cfg(feature = "frozen-abi")]
 use proc_macro2::{Span, TokenStream as TokenStream2, TokenTree};
 #[cfg(feature = "frozen-abi")]
@@ -156,30 +192,27 @@ fn derive_abi_sample_enum_type(input: ItemEnum) -> TokenStream {
 #[cfg(feature = "frozen-abi")]
 fn derive_abi_sample_struct_type(input: ItemStruct) -> TokenStream {
     let type_name = &input.ident;
-    let mut sample_fields = quote! {};
     let fields = &input.fields;
+    let mut sample_fields = quote! {};
 
     match fields {
         Fields::Named(_) => {
             for field in fields {
                 let field_name = &field.ident;
+
                 sample_fields.extend(quote! {
                     #field_name: AbiExample::example(),
                 });
             }
-            sample_fields = quote! {
-                { #sample_fields }
-            }
+            sample_fields = quote! {{ #sample_fields }};
         }
         Fields::Unnamed(_) => {
             for _ in fields {
                 sample_fields.extend(quote! {
                     AbiExample::example(),
                 });
             }
-            sample_fields = quote! {
-                ( #sample_fields )
-            }
+            sample_fields = quote! {( #sample_fields )};
         }
         _ => unimplemented!("fields: {:?}", fields),
     }
@@ -195,7 +228,7 @@ fn derive_abi_sample_struct_type(input: ItemStruct) -> TokenStream {
         impl #impl_generics ::solana_frozen_abi::abi_example::AbiExample for #type_name #ty_generics #where_clause {
             fn example() -> Self {
                 ::std::println!(
-                    "AbiExample for struct: {}",
+                    "AbiExample::example for struct: {}",
                     std::any::type_name::<#type_name #ty_generics>()
                 );
                 use ::solana_frozen_abi::abi_example::AbiExample;
@@ -277,39 +310,61 @@ pub fn derive_abi_enum_visitor(item: TokenStream) -> TokenStream {
 fn quote_for_test(
     test_mod_ident: &Ident,
     type_name: &Ident,
-    expected_digest: &str,
+    expected_api_digest: Option<&str>,
+    expected_abi_digest: Option<&str>,
 ) -> TokenStream2 {
-    quote! {
-        #[cfg(test)]
-        mod #test_mod_ident {
-            use super::*;
-            use ::solana_frozen_abi::abi_example::{AbiExample, AbiEnumVisitor};
-
+    let test_api = if expected_api_digest.is_some() {
+        quote! {
             #[test]
-            fn test_abi_digest() {
+            fn test_api_digest() {
+                use ::solana_frozen_abi::abi_example::{AbiExample, AbiEnumVisitor};
                 let mut digester = ::solana_frozen_abi::abi_digester::AbiDigester::create();
                 let example = <#type_name>::example();
                 let result = <_>::visit_for_abi(&&example, &mut digester);
-                let mut hash = digester.finalize();
-                if result.is_err() {
-                    ::std::eprintln!("Error: digest error: {:#?}", result);
-                }
                 result.unwrap();
-                let actual_digest = ::std::format!("{}", hash);
-                if ::std::env::var("SOLANA_ABI_BULK_UPDATE").is_ok() {
-                    if #expected_digest != actual_digest {
-                        ::std::eprintln!("sed -i -e 's/{}/{}/g' $(git grep --files-with-matches frozen_abi)", #expected_digest, hash);
-                    }
-                    ::std::eprintln!("Warning: Not testing the abi digest under SOLANA_ABI_BULK_UPDATE!");
-                } else {
-                    if let Ok(dir) = ::std::env::var("SOLANA_ABI_DUMP_DIR") {
-                        assert_eq!(#expected_digest, actual_digest, "Possibly ABI changed? Examine the diff in SOLANA_ABI_DUMP_DIR!: \n$ diff -u {}/*{}* {}/*{}*", dir, #expected_digest, dir, actual_digest);
-                    } else {
-                        assert_eq!(#expected_digest, actual_digest, "Possibly ABI changed? Confirm the diff by rerunning before and after this test failed with SOLANA_ABI_DUMP_DIR!");
-                    }
+                let hash = digester.finalize();
+                assert_eq!(#expected_api_digest, format!("{}", hash));
+            }
+        }
+    } else {
+        TokenStream2::new()
+    };
+
+    let test_abi = if expected_abi_digest.is_some() {
+        quote! {
+            #[test]
+            fn test_abi_digest() {
+                use ::rand::{SeedableRng, RngCore};
+                use ::rand_chacha::ChaCha8Rng;
+                use ::bincode;
+                use ::solana_frozen_abi::stable_abi::StableAbi;
+
+                let mut rng = ChaCha8Rng::seed_from_u64(20666175621446498);
+                let mut digester = ::solana_frozen_abi::hash::Hasher::default();
+
+                for _ in 0..100_000 {
+                    let val = <#type_name>::random(&mut rng);
+                    digester.hash(&bincode::serialize(&val).unwrap());
                 }
+                assert_eq!(#expected_abi_digest, format!("{}", digester.result()));
             }
         }
+    } else {
+        TokenStream2::new()
+    };
+
+    let no_tests = test_api.is_empty() && test_abi.is_empty();
+    if no_tests {
+        return TokenStream2::new();
+    }
+
+    quote! {
+        #[cfg(test)]
+        mod #test_mod_ident {
+            use super::*;
+            #test_api
+            #test_abi
+        }
     }
 }
 
@@ -319,9 +374,18 @@ fn test_mod_name(type_name: &Ident) -> Ident {
 }
 
 #[cfg(feature = "frozen-abi")]
-fn frozen_abi_type_alias(input: ItemType, expected_digest: &str) -> TokenStream {
+fn frozen_abi_type_alias(
+    input: ItemType,
+    expected_api_digest: Option<&str>,
+    expected_abi_digest: Option<&str>,
+) -> TokenStream {
     let type_name = &input.ident;
-    let test = quote_for_test(&test_mod_name(type_name), type_name, expected_digest);
+    let test = quote_for_test(
+        &test_mod_name(type_name),
+        type_name,
+        expected_api_digest,
+        expected_abi_digest,
+    );
     let result = quote! {
         #input
         #test
@@ -330,9 +394,18 @@ fn frozen_abi_type_alias(input: ItemType, expected_digest: &str) -> TokenStream
 }
 
 #[cfg(feature = "frozen-abi")]
-fn frozen_abi_struct_type(input: ItemStruct, expected_digest: &str) -> TokenStream {
+fn frozen_abi_struct_type(
+    input: ItemStruct,
+    expected_api_digest: Option<&str>,
+    expected_abi_digest: Option<&str>,
+) -> TokenStream {
     let type_name = &input.ident;
-    let test = quote_for_test(&test_mod_name(type_name), type_name, expected_digest);
+    let test = quote_for_test(
+        &test_mod_name(type_name),
+        type_name,
+        expected_api_digest,
+        expected_abi_digest,
+    );
     let result = quote! {
         #input
         #test
@@ -387,9 +460,18 @@ fn quote_sample_variant(
 }
 
 #[cfg(feature = "frozen-abi")]
-fn frozen_abi_enum_type(input: ItemEnum, expected_digest: &str) -> TokenStream {
+fn frozen_abi_enum_type(
+    input: ItemEnum,
+    expected_api_digest: Option<&str>,
+    expected_abi_digest: Option<&str>,
+) -> TokenStream {
     let type_name = &input.ident;
-    let test = quote_for_test(&test_mod_name(type_name), type_name, expected_digest);
+    let test = quote_for_test(
+        &test_mod_name(type_name),
+        type_name,
+        expected_api_digest,
+        expected_abi_digest,
+    );
     let result = quote! {
         #input
         #test
@@ -400,31 +482,40 @@ fn frozen_abi_enum_type(input: ItemEnum, expected_digest: &str) -> TokenStream {
 #[cfg(feature = "frozen-abi")]
 #[proc_macro_attribute]
 pub fn frozen_abi(attrs: TokenStream, item: TokenStream) -> TokenStream {
-    let mut expected_digest: Option<String> = None;
+    let mut api_expected_digest: Option<String> = None;
+    let mut abi_expected_digest: Option<String> = None;
+
     let attrs_parser = syn::meta::parser(|meta| {
         if meta.path.is_ident("digest") {
-            expected_digest = Some(meta.value()?.parse::<LitStr>()?.value());
+            api_expected_digest = Some(meta.value()?.parse::<LitStr>()?.value());
+            Ok(())
+        } else if meta.path.is_ident("abi_digest") {
+            abi_expected_digest = Some(meta.value()?.parse::<LitStr>()?.value());
             Ok(())
         } else {
             Err(meta.error("unsupported \"frozen_abi\" property"))
         }
     });
     parse_macro_input!(attrs with attrs_parser);
 
-    let Some(expected_digest) = expected_digest else {
-        return Error::new_spanned(
-            TokenStream2::from(item),
-            "the required \"digest\" = ... attribute is missing.",
-        )
-        .to_compile_error()
-        .into();
-    };
-
     let item = parse_macro_input!(item as Item);
+
     match item {
-        Item::Struct(input) => frozen_abi_struct_type(input, &expected_digest),
-        Item::Enum(input) => frozen_abi_enum_type(input, &expected_digest),
-        Item::Type(input) => frozen_abi_type_alias(input, &expected_digest),
+        Item::Struct(input) => frozen_abi_struct_type(
+            input,
+            api_expected_digest.as_deref(),
+            abi_expected_digest.as_deref(),
+        ),
+        Item::Enum(input) => frozen_abi_enum_type(
+            input,
+            api_expected_digest.as_deref(),
+            abi_expected_digest.as_deref(),
+        ),
+        Item::Type(input) => frozen_abi_type_alias(
+            input,
+            api_expected_digest.as_deref(),
+            abi_expected_digest.as_deref(),
+        ),
         _ => Error::new_spanned(
             item,
             "frozen_abi isn't applicable; only for struct, enum and type",

frozen-abi-macro/src/lib.rs

@@ -0,0 +1,17 @@
+[package]
+name = "frozen-abi-test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+bincode = { workspace = true }
+rand = { workspace = true }
+rand_chacha = "0.3"
+sha2 = { workspace = true }
+
+solana-frozen-abi = { path = "../frozen-abi", features = ["frozen-abi"] }
+solana-frozen-abi-macro = { path = "../frozen-abi-macro", features = ["frozen-abi"] }
+
+[features]
+frozen-abi = []

frozen-abi-test/Cargo.toml

@@ -0,0 +1,31 @@
+#![cfg_attr(feature = "frozen-abi", feature(min_specialization))]
+
+use rand::distributions::{Distribution, Standard};
+use rand::Rng;
+use serde::{Deserialize, Serialize};
+use solana_frozen_abi_macro::frozen_abi;
+use solana_frozen_abi_macro::AbiExample;
+use solana_frozen_abi_macro::StableAbi;
+
+#[cfg_attr(feature = "frozen-abi", derive(StableAbi), derive(AbiExample))]
+#[cfg_attr(
+    feature = "frozen-abi",
+    frozen_abi(
+        api_digest = "H4pHPLGaqzQVAnMDKCgHD3R5sqWNxZwpCuZpmukAQSa",
+        abi_digest = "5RoDSUMyqu38JmXiZBKXzAGRuku7JfHtKamyGqnYN7ND"
+    )
+)]
+#[derive(Serialize, Deserialize)]
+pub struct BlockhashQueue {
+    pub last_hash_index: u64,
+    pub a: u16,
+}
+
+impl Distribution<BlockhashQueue> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> BlockhashQueue {
+        BlockhashQueue {
+            last_hash_index: rng.gen(),
+            a: rng.gen(),
+        }
+    }
+}

frozen-abi-test/src/lib.rs

@@ -33,6 +33,7 @@ serde_with = { workspace = true }
 sha2 = { workspace = true }
 solana-frozen-abi-macro = { workspace = true }
 thiserror = { workspace = true }
+rand = { workspace = true }
 
 [target.'cfg(not(target_os = "solana"))'.dependencies]
 im = { workspace = true, features = ["rayon", "serde"] }