chore: hasher and light hasher macro support for sha256

.github/workflows/rust.yml

@@ -47,6 +47,7 @@ jobs:
               aligned-sized light-hasher light-compressed-account light-account-checks \
               light-verifier light-merkle-tree-metadata light-zero-copy light-hash-set
             test_cmd: |
+              cargo test -p light-macros
               cargo test -p aligned-sized
               cargo test -p light-hasher --all-features
               cargo test -p light-compressed-account --all-features

.github/workflows/sdk-tests.yml

@@ -56,10 +56,12 @@ jobs:
           - program: sdk-anchor-test-program
             sub-tests: '["cargo-test-sbf -p sdk-anchor-test", "cargo-test-sbf -p sdk-pinocchio-test"]'
           - program: sdk-libs
-            packages: light-macros light-sdk light-program-test light-client light-batched-merkle-tree
+            packages: light-sdk-macros light-sdk light-program-test light-client light-batched-merkle-tree
             test_cmd: |
-              cargo test -p light-macros
+              cargo test -p light-sdk-macros
+              cargo test -p light-sdk-macros --all-features
               cargo test -p light-sdk
+              cargo test -p light-sdk --all-features
               cargo test -p light-program-test
               cargo test -p light-client
               cargo test -p client-test

program-libs/hasher/src/keccak.rs

@@ -9,6 +9,8 @@ use crate::{
 pub struct Keccak;
 
 impl Hasher for Keccak {
+    const ID: u8 = 2;
+
     fn hash(val: &[u8]) -> Result<Hash, HasherError> {
         Self::hashv(&[val])
     }

program-libs/hasher/src/lib.rs

@@ -24,6 +24,7 @@ pub const HASH_BYTES: usize = 32;
 pub type Hash = [u8; HASH_BYTES];
 
 pub trait Hasher {
+    const ID: u8;
     fn hash(val: &[u8]) -> Result<Hash, HasherError>;
     fn hashv(vals: &[&[u8]]) -> Result<Hash, HasherError>;
     fn zero_bytes() -> ZeroBytes;

program-libs/hasher/src/poseidon.rs

@@ -78,6 +78,8 @@ impl From<PoseidonSyscallError> for u64 {
 pub struct Poseidon;
 
 impl Hasher for Poseidon {
+    const ID: u8 = 0;
+
     fn hash(val: &[u8]) -> Result<Hash, HasherError> {
         Self::hashv(&[val])
     }

program-libs/hasher/src/sha256.rs

@@ -5,10 +5,22 @@ use crate::{
     Hash, Hasher,
 };
 
+/// Compile-time assertion trait that ensures a generic Hasher type is SHA256.
+/// Used by LightHasherSha macro to enforce SHA256-only implementation at compile time.
+pub trait RequireSha256: Hasher {
+    const ASSERT: () = assert!(
+        Self::ID == 1,
+        "DataHasher for LightHasherSha only works with SHA256 (ID=1). Example: your_struct.hash::<Sha256>()?"
+    );
+}
+
+impl<T: Hasher> RequireSha256 for T {}
+
 #[derive(Clone, Copy)] // To allow using with zero copy Solana accounts.
 pub struct Sha256;
 
 impl Hasher for Sha256 {
+    const ID: u8 = 1;
     fn hash(val: &[u8]) -> Result<Hash, HasherError> {
         Self::hashv(&[val])
     }

sdk-libs/macros/Cargo.toml

@@ -6,6 +6,10 @@ repository = "https://github.com/Lightprotocol/light-protocol"
 license = "Apache-2.0"
 edition = "2021"
 
+
+[features]
+anchor-discriminator = []
+
 [dependencies]
 proc-macro2 = { workspace = true }
 quote = { workspace = true }
@@ -22,6 +26,7 @@ prettyplease = "0.2.29"
 solana-pubkey = { workspace = true, features = ["borsh"] }
 borsh = { workspace = true }
 light-macros = { workspace = true }
+light-account-checks = { workspace = true }
 
 [lib]
 proc-macro = true

sdk-libs/macros/src/discriminator.rs

@@ -5,11 +5,17 @@ use syn::{ItemStruct, Result};
 
 pub(crate) fn discriminator(input: ItemStruct) -> Result<TokenStream> {
     let account_name = &input.ident;
+    // When anchor-discriminator-compat feature is enabled, use "account:" prefix like Anchor does
+    #[cfg(feature = "anchor-discriminator")]
+    let hash_input = format!("account:{}", account_name);
+
+    #[cfg(not(feature = "anchor-discriminator"))]
+    let hash_input = account_name.to_string();
 
     let (impl_gen, type_gen, where_clause) = input.generics.split_for_impl();
 
     let mut discriminator = [0u8; 8];
-    discriminator.copy_from_slice(&Sha256::hash(account_name.to_string().as_bytes()).unwrap()[..8]);
+    discriminator.copy_from_slice(&Sha256::hash(hash_input.as_bytes()).unwrap()[..8]);
     let discriminator: proc_macro2::TokenStream = format!("{discriminator:?}").parse().unwrap();
 
     Ok(quote! {
@@ -26,12 +32,14 @@ pub(crate) fn discriminator(input: ItemStruct) -> Result<TokenStream> {
 
 #[cfg(test)]
 mod tests {
-    use syn::parse_quote;
-
-    use super::*;
 
+    #[cfg(not(feature = "anchor-discriminator"))]
     #[test]
     fn test_discriminator() {
+        use syn::parse_quote;
+
+        use super::*;
+
         let input: ItemStruct = parse_quote! {
             struct MyAccount {
                 a: u32,

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

@@ -37,7 +37,14 @@ pub(crate) fn generate_data_hasher_impl(
                         slices[num_flattned_fields] = element.as_slice();
                     }
 
-                    H::hashv(slices.as_slice())
+                    let mut result = H::hashv(slices.as_slice())?;
+
+                    // Apply field size truncation for non-Poseidon hashers
+                    if H::ID != ::light_hasher::Poseidon::ID {
+                        result[0] = 0;
+                    }
+
+                    Ok(result)
                 }
             }
         }
@@ -59,13 +66,53 @@ pub(crate) fn generate_data_hasher_impl(
                             println!("DataHasher::hash inputs {:?}", debug_prints);
                        }
                    }
-                    H::hashv(&[
+                    let mut result = H::hashv(&[
                         #(#data_hasher_assignments.as_slice(),)*
-                    ])
+                    ])?;
+
+                    // Apply field size truncation for non-Poseidon hashers
+                    if H::ID != ::light_hasher::Poseidon::ID {
+                        result[0] = 0;
+                    }
+
+                    Ok(result)
                 }
             }
         }
     };
 
     Ok(hasher_impl)
 }
+
+/// SHA256-specific DataHasher implementation that serializes the whole struct
+pub(crate) fn generate_data_hasher_impl_sha(
+    struct_name: &syn::Ident,
+    generics: &syn::Generics,
+) -> Result<TokenStream> {
+    let (impl_gen, type_gen, where_clause) = generics.split_for_impl();
+
+    let hasher_impl = quote! {
+        impl #impl_gen ::light_hasher::DataHasher for #struct_name #type_gen #where_clause {
+            fn hash<H>(&self) -> ::std::result::Result<[u8; 32], ::light_hasher::HasherError>
+            where
+                H: ::light_hasher::Hasher
+            {
+                use ::light_hasher::Hasher;
+                use borsh::BorshSerialize;
+
+                // Compile-time assertion that H must be SHA256 (ID = 1)
+                use ::light_hasher::sha256::RequireSha256;
+                let _ = <H as RequireSha256>::ASSERT;
+
+                // For SHA256, we serialize the whole struct and hash it in one go
+                let serialized = self.try_to_vec().map_err(|_| ::light_hasher::HasherError::BorshError)?;
+                let mut result = H::hash(&serialized)?;
+                // Truncate sha256 to 31 be bytes less than 254 bits bn254 field size.
+                result[0] = 0;
+                Ok(result)
+            }
+        }
+    };
+
+    Ok(hasher_impl)
+}

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

@@ -60,6 +60,36 @@ pub(crate) fn validate_input(input: &ItemStruct) -> Result<()> {
     Ok(())
 }
 
+/// SHA256-specific validation - much more relaxed constraints
+pub(crate) fn validate_input_sha(input: &ItemStruct) -> Result<()> {
+    // Check that we have a struct with named fields
+    match &input.fields {
+        Fields::Named(_) => (),
+        _ => {
+            return Err(Error::new_spanned(
+                input,
+                "Only structs with named fields are supported",
+            ))
+        }
+    };
+
+    // For SHA256, we don't limit field count or require specific attributes
+    // Just ensure flatten is not used (not implemented for SHA256 path)
+    let flatten_field_exists = input
+        .fields
+        .iter()
+        .any(|field| get_field_attribute(field) == FieldAttribute::Flatten);
+
+    if flatten_field_exists {
+        return Err(Error::new_spanned(
+            input,
+            "Flatten attribute is not supported in SHA256 hasher.",
+        ));
+    }
+
+    Ok(())
+}
+
 /// Gets the primary attribute for a field (only one attribute can be active)
 pub(crate) fn get_field_attribute(field: &Field) -> FieldAttribute {
     if field.attrs.iter().any(|attr| attr.path().is_ident("hash")) {