update lightdiscriminator macro

Author: SwenSchaeferjohann

sdk-libs/macros/src/discriminator.rs

@@ -4,6 +4,14 @@ use quote::quote;
 use syn::{ItemStruct, Result};
 
 pub(crate) fn discriminator(input: ItemStruct) -> Result<TokenStream> {
+    discriminator_with_hasher(input, false)
+}
+
+pub(crate) fn discriminator_sha(input: ItemStruct) -> Result<TokenStream> {
+    discriminator_with_hasher(input, true)
+}
+
+fn discriminator_with_hasher(input: ItemStruct, is_sha: bool) -> Result<TokenStream> {
     let account_name = &input.ident;
 
     let (impl_gen, type_gen, where_clause) = input.generics.split_for_impl();
@@ -12,6 +20,10 @@ pub(crate) fn discriminator(input: ItemStruct) -> Result<TokenStream> {
     discriminator.copy_from_slice(&Sha256::hash(account_name.to_string().as_bytes()).unwrap()[..8]);
     let discriminator: proc_macro2::TokenStream = format!("{discriminator:?}").parse().unwrap();
 
+    // For SHA256 variant, we could add specific logic here if needed
+    // Currently both variants work the same way since discriminator is just based on struct name
+    let _variant_marker = if is_sha { "sha256" } else { "poseidon" };
+
     Ok(quote! {
         impl #impl_gen LightDiscriminator for #account_name #type_gen #where_clause {
             const LIGHT_DISCRIMINATOR: [u8; 8] = #discriminator;
@@ -47,4 +59,46 @@ mod tests {
         assert!(output.contains("impl LightDiscriminator for MyAccount"));
         assert!(output.contains("[181 , 255 , 112 , 42 , 17 , 188 , 66 , 199]"));
     }
+
+    #[test]
+    fn test_discriminator_sha() {
+        let input: ItemStruct = parse_quote! {
+            struct MyAccount {
+                a: u32,
+                b: i32,
+                c: u64,
+                d: i64,
+            }
+        };
+
+        let output = discriminator_sha(input).unwrap();
+        let output = output.to_string();
+
+        assert!(output.contains("impl LightDiscriminator for MyAccount"));
+        assert!(output.contains("[181 , 255 , 112 , 42 , 17 , 188 , 66 , 199]"));
+    }
+
+    #[test]
+    fn test_discriminator_sha_large_struct() {
+        // Test that SHA256 discriminator can handle large structs (that would fail with regular hasher)
+        let input: ItemStruct = parse_quote! {
+            struct LargeAccount {
+                pub field1: u64, pub field2: u64, pub field3: u64, pub field4: u64,
+                pub field5: u64, pub field6: u64, pub field7: u64, pub field8: u64,
+                pub field9: u64, pub field10: u64, pub field11: u64, pub field12: u64,
+                pub field13: u64, pub field14: u64, pub field15: u64,
+                pub owner: solana_program::pubkey::Pubkey,
+                pub authority: solana_program::pubkey::Pubkey,
+            }
+        };
+
+        let result = discriminator_sha(input);
+        assert!(
+            result.is_ok(),
+            "SHA256 discriminator should handle large structs"
+        );
+
+        let output = result.unwrap().to_string();
+        assert!(output.contains("impl LightDiscriminator for LargeAccount"));
+    }
 }

sdk-libs/macros/src/hasher/light_hasher.rs

@@ -276,7 +276,7 @@ impl ::light_hasher::DataHasher for TruncateOptionStruct {
         #[cfg(debug_assertions)]
        {
             if std::env::var("RUST_BACKTRACE").is_ok() {
-                let debug_prints: Vec<[u8; 32]> = vec![
+                let debug_prints: Vec<[u8;32]> = vec![
                     if let Some(a) = & self.a { let result = a.hash_to_field_size() ?; if
                     result == [0u8; 32] { return
                     Err(::light_hasher::errors::HasherError::OptionHashToFieldSizeZero); }
@@ -560,4 +560,154 @@ impl ::light_hasher::DataHasher for OuterStruct {
             "Should mention SHA256 limitation"
         );
     }
+
+    #[test]
+    fn test_sha256_with_discriminator_integration() {
+        // Test that shows LightHasherSha works with LightDiscriminatorSha for large structs
+        // This would be impossible with regular Poseidon-based macros
+        let input: ItemStruct = parse_quote! {
+            struct LargeIntegratedAccount {
+                pub field1: u64, pub field2: u64, pub field3: u64, pub field4: u64,
+                pub field5: u64, pub field6: u64, pub field7: u64, pub field8: u64,
+                pub field9: u64, pub field10: u64, pub field11: u64, pub field12: u64,
+                pub field13: u64, pub field14: u64, pub field15: u64, pub field16: u64,
+                pub field17: u64, pub field18: u64, pub field19: u64, pub field20: u64,
+                // Pubkeys without #[hash] attribute
+                pub owner: solana_program::pubkey::Pubkey,
+                pub authority: solana_program::pubkey::Pubkey,
+                pub delegate: solana_program::pubkey::Pubkey,
+            }
+        };
+
+        // Both SHA256 hasher and discriminator should work
+        let sha_hasher_result = derive_light_hasher_sha(input.clone());
+        assert!(
+            sha_hasher_result.is_ok(),
+            "SHA256 hasher should work with large structs"
+        );
+
+        let sha_discriminator_result = crate::discriminator::discriminator_sha(input.clone());
+        assert!(
+            sha_discriminator_result.is_ok(),
+            "SHA256 discriminator should work with large structs"
+        );
+
+        // Regular Poseidon variants should fail
+        let poseidon_hasher_result = derive_light_hasher(input);
+        assert!(
+            poseidon_hasher_result.is_err(),
+            "Poseidon hasher should fail with large structs"
+        );
+
+        // Verify the generated code contains expected patterns
+        let sha_hasher_code = sha_hasher_result.unwrap().to_string();
+        assert!(
+            sha_hasher_code.contains("try_to_vec"),
+            "Should use serialization approach"
+        );
+        assert!(
+            sha_hasher_code.contains("BorshSerialize"),
+            "Should use Borsh serialization"
+        );
+
+        let sha_discriminator_code = sha_discriminator_result.unwrap().to_string();
+        assert!(
+            sha_discriminator_code.contains("LightDiscriminator"),
+            "Should implement LightDiscriminator"
+        );
+        assert!(
+            sha_discriminator_code.contains("LIGHT_DISCRIMINATOR"),
+            "Should provide discriminator constant"
+        );
+    }
+
+    #[test]
+    fn test_complete_sha256_ecosystem_practical_example() {
+        // Demonstrates a real-world scenario where SHA256 variants are essential
+        // This struct would be impossible with Poseidon due to:
+        // 1. >12 fields (23+ fields)
+        // 2. Multiple Pubkeys without #[hash] attribute
+        // 3. Large data structures
+        let input: ItemStruct = parse_quote! {
+            pub struct ComplexGameState {
+                // Game metadata (13 fields)
+                pub game_id: u64,
+                pub round: u32,
+                pub turn: u8,
+                pub phase: u8,
+                pub start_time: i64,
+                pub end_time: i64,
+                pub max_players: u8,
+                pub current_players: u8,
+                pub entry_fee: u64,
+                pub prize_pool: u64,
+                pub game_mode: u32,
+                pub difficulty: u8,
+                pub status: u8,
+
+                // Player information (6 Pubkey fields - would require #[hash] with Poseidon)
+                pub creator: solana_program::pubkey::Pubkey,
+                pub winner: solana_program::pubkey::Pubkey,
+                pub current_player: solana_program::pubkey::Pubkey,
+                pub authority: solana_program::pubkey::Pubkey,
+                pub treasury: solana_program::pubkey::Pubkey,
+                pub program_id: solana_program::pubkey::Pubkey,
+
+                // Game state data (4+ more fields)
+                pub board_state: [u8; 64],    // Large array
+                pub player_scores: [u32; 8],  // Array of scores
+                pub moves_history: [u16; 32], // Move history
+                pub special_flags: u32,
+
+                // This gives us 23+ fields total - way beyond Poseidon's 12-field limit
+            }
+        };
+
+        // SHA256 variants should handle this complex struct effortlessly
+        let sha_hasher_result = derive_light_hasher_sha(input.clone());
+        assert!(
+            sha_hasher_result.is_ok(),
+            "SHA256 hasher must handle complex real-world structs"
+        );
+
+        let sha_discriminator_result = crate::discriminator::discriminator_sha(input.clone());
+        assert!(
+            sha_discriminator_result.is_ok(),
+            "SHA256 discriminator must handle complex real-world structs"
+        );
+
+        // Poseidon would fail with this struct
+        let poseidon_result = derive_light_hasher(input);
+        assert!(
+            poseidon_result.is_err(),
+            "Poseidon cannot handle structs with >12 fields and unhashed Pubkeys"
+        );
+
+        // Verify SHA256 generates efficient serialization-based code
+        let hasher_code = sha_hasher_result.unwrap().to_string();
+        assert!(
+            hasher_code.contains("try_to_vec"),
+            "Should serialize entire struct efficiently"
+        );
+        assert!(
+            hasher_code.contains("BorshSerialize"),
+            "Should use Borsh for serialization"
+        );
+        assert!(
+            hasher_code.contains("result [0] = 0") || hasher_code.contains("result[0] = 0"),
+            "Should apply field size truncation. Actual code: {}",
+            hasher_code
+        );
+
+        // Verify discriminator works correctly
+        let discriminator_code = sha_discriminator_result.unwrap().to_string();
+        assert!(
+            discriminator_code.contains("ComplexGameState"),
+            "Should target correct struct"
+        );
+        assert!(
+            discriminator_code.contains("LIGHT_DISCRIMINATOR"),
+            "Should provide discriminator constant"
+        );
+    }
 }

sdk-libs/macros/src/lib.rs

@@ -1,5 +1,6 @@
 extern crate proc_macro;
 use accounts::{process_light_accounts, process_light_system_accounts};
+use discriminator::{discriminator, discriminator_sha};
 use hasher::{derive_light_hasher, derive_light_hasher_sha};
 use proc_macro::TokenStream;
 use syn::{parse_macro_input, DeriveInput, ItemMod, ItemStruct};
@@ -135,7 +136,35 @@ pub fn light_traits_derive(input: TokenStream) -> TokenStream {
 #[proc_macro_derive(LightDiscriminator)]
 pub fn light_discriminator(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as ItemStruct);
-    discriminator::discriminator(input)
+    discriminator(input)
+        .unwrap_or_else(|err| err.to_compile_error())
+        .into()
+}
+
+/// SHA256 variant of the LightDiscriminator derive macro.
+///
+/// This derive macro provides the same discriminator functionality as LightDiscriminator
+/// but is designed to be used with SHA256-based hashing for consistency.
+///
+/// ## Example
+///
+/// ```ignore
+/// use light_sdk::sha::{LightHasher, LightDiscriminator};
+///
+/// #[derive(LightHasher, LightDiscriminator)]
+/// pub struct LargeGameState {
+///     pub field1: u64, pub field2: u64, pub field3: u64, pub field4: u64,
+///     pub field5: u64, pub field6: u64, pub field7: u64, pub field8: u64,
+///     pub field9: u64, pub field10: u64, pub field11: u64, pub field12: u64,
+///     pub field13: u64, pub field14: u64, pub field15: u64,
+///     pub owner: Pubkey,
+///     pub authority: Pubkey,
+/// }
+/// ```
+#[proc_macro_derive(LightDiscriminatorSha)]
+pub fn light_discriminator_sha(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as ItemStruct);
+    discriminator_sha(input)
         .unwrap_or_else(|err| err.to_compile_error())
         .into()
 }

sdk-libs/sdk/src/lib.rs

@@ -107,7 +107,9 @@ pub use account::LightAccount;
 
 /// SHA256-based variants
 pub mod sha {
-    pub use light_sdk_macros::LightHasherSha as LightHasher;
+    pub use light_sdk_macros::{
+        LightDiscriminatorSha as LightDiscriminator, LightHasherSha as LightHasher,
+    };
 
     pub use crate::account::sha::LightAccount;
 }
@@ -132,8 +134,8 @@ use borsh::{BorshDeserialize as AnchorDeserialize, BorshSerialize as AnchorSeria
 pub use light_account_checks::{self, discriminator::Discriminator as LightDiscriminator};
 pub use light_hasher;
 pub use light_sdk_macros::{
-    derive_light_cpi_signer, light_system_accounts, LightDiscriminator, LightHasher,
-    LightHasherSha, LightTraits,
+    derive_light_cpi_signer, light_system_accounts, LightDiscriminator, LightDiscriminatorSha,
+    LightHasher, LightHasherSha, LightTraits,
 };
 pub use light_sdk_types::constants;
 use solana_account_info::AccountInfo;