add sha hash function support to LightAccount and LightHasher + tests

SwenSchaeferjohann · SwenSchaeferjohann · commit a778539a1b86 · 2025-07-29T10:57:06.000-04:00
diff --git a/program-libs/hasher/src/keccak.rs b/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])
     }
diff --git a/program-libs/hasher/src/lib.rs b/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;
diff --git a/program-libs/hasher/src/poseidon.rs b/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])
     }
diff --git a/program-libs/hasher/src/sha256.rs b/program-libs/hasher/src/sha256.rs
@@ -9,6 +9,7 @@ use crate::{
 pub struct Sha256;
 
 impl Hasher for Sha256 {
+    const ID: u8 = 1;
     fn hash(val: &[u8]) -> Result<Hash, HasherError> {
         Self::hashv(&[val])
     }
diff --git a/sdk-libs/macros/src/compressible.rs b/sdk-libs/macros/src/compressible.rs
diff --git a/sdk-libs/macros/src/hasher/data_hasher.rs b/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 != 0 {
+                        result[0] = 0;
+                    }
+
+                    Ok(result)
                 }
             }
         }
@@ -59,9 +66,16 @@ 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 != 0 {
+                        result[0] = 0;
+                    }
+
+                    Ok(result)
                 }
             }
         }
diff --git a/sdk-libs/macros/src/hasher/light_hasher.rs b/sdk-libs/macros/src/hasher/light_hasher.rs
@@ -6,7 +6,7 @@ use crate::hasher::{
     data_hasher::generate_data_hasher_impl,
     field_processor::{process_field, FieldProcessingContext},
     input_validator::{get_field_attribute, validate_input, FieldAttribute},
-    to_byte_array::generate_to_byte_array_impl,
+    to_byte_array::generate_to_byte_array_impl_with_hasher,
 };
 
 /// - ToByteArray:
@@ -49,6 +49,14 @@ use crate::hasher::{
 /// - Enums, References, SmartPointers:
 ///     - Not supported
 pub(crate) fn derive_light_hasher(input: ItemStruct) -> Result<TokenStream> {
+    derive_light_hasher_with_hasher(input, &quote!(::light_hasher::Poseidon))
+}
+
+pub(crate) fn derive_light_hasher_sha(input: ItemStruct) -> Result<TokenStream> {
+    derive_light_hasher_with_hasher(input, &quote!(::light_hasher::Sha256))
+}
+
+fn derive_light_hasher_with_hasher(input: ItemStruct, hasher: &TokenStream) -> Result<TokenStream> {
     // Validate the input structure
     validate_input(&input)?;
 
@@ -74,8 +82,13 @@ pub(crate) fn derive_light_hasher(input: ItemStruct) -> Result<TokenStream> {
         process_field(field, i, &mut context);
     });
 
-    let to_byte_array_impl =
-        generate_to_byte_array_impl(&input.ident, &generics, field_count, &context)?;
+    let to_byte_array_impl = generate_to_byte_array_impl_with_hasher(
+        &input.ident,
+        &generics,
+        field_count,
+        &context,
+        hasher,
+    )?;
 
     let data_hasher_impl = generate_data_hasher_impl(&input.ident, &generics, &context)?;
 
diff --git a/sdk-libs/macros/src/hasher/mod.rs b/sdk-libs/macros/src/hasher/mod.rs
@@ -4,4 +4,4 @@ mod input_validator;
 mod light_hasher;
 mod to_byte_array;
 
-pub(crate) use light_hasher::derive_light_hasher;
+pub(crate) use light_hasher::{derive_light_hasher, derive_light_hasher_sha};
diff --git a/sdk-libs/macros/src/hasher/to_byte_array.rs b/sdk-libs/macros/src/hasher/to_byte_array.rs
@@ -4,11 +4,12 @@ use syn::Result;
 
 use crate::hasher::field_processor::FieldProcessingContext;
 
-pub(crate) fn generate_to_byte_array_impl(
+pub(crate) fn generate_to_byte_array_impl_with_hasher(
     struct_name: &syn::Ident,
     generics: &syn::Generics,
     field_count: usize,
     context: &FieldProcessingContext,
+    hasher: &TokenStream,
 ) -> Result<TokenStream> {
     let (impl_gen, type_gen, where_clause) = generics.split_for_impl();
 
@@ -44,7 +45,7 @@ pub(crate) fn generate_to_byte_array_impl(
                 const NUM_FIELDS: usize = #field_count;
 
                 fn to_byte_array(&self) -> ::std::result::Result<[u8; 32], ::light_hasher::HasherError> {
-                    ::light_hasher::DataHasher::hash::<::light_hasher::Poseidon>(self)
+                    ::light_hasher::DataHasher::hash::<#hasher>(self)
                 }
 
             }
diff --git a/sdk-libs/macros/src/lib.rs b/sdk-libs/macros/src/lib.rs
@@ -1,6 +1,6 @@
 extern crate proc_macro;
 use accounts::{process_light_accounts, process_light_system_accounts};
-use hasher::derive_light_hasher;
+use hasher::{derive_light_hasher, derive_light_hasher_sha};
 use proc_macro::TokenStream;
 use syn::{parse_macro_input, DeriveInput, ItemStruct};
 use traits::process_light_traits;
@@ -193,6 +193,32 @@ pub fn light_hasher(input: TokenStream) -> TokenStream {
         .into()
 }
 
+/// SHA256 variant of the LightHasher derive macro.
+///
+/// This derive macro automatically implements the `DataHasher` and `ToByteArray` traits
+/// for structs, using SHA256 as the hashing algorithm instead of Poseidon.
+///
+/// ## Example
+///
+/// ```ignore
+/// use light_sdk::sha::LightHasher;
+///
+/// #[derive(LightHasher)]
+/// pub struct GameState {
+///     #[hash]
+///     pub player: Pubkey,  // Will be hashed to 31 bytes
+///     pub level: u32,
+/// }
+/// ```
+#[proc_macro_derive(LightHasherSha, attributes(hash, skip))]
+pub fn light_hasher_sha(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as ItemStruct);
+
+    derive_light_hasher_sha(input)
+        .unwrap_or_else(|err| err.to_compile_error())
+        .into()
+}
+
 /// Automatically implements the HasCompressionInfo trait for structs that have a
 /// `compression_info: Option<CompressionInfo>` field.
 ///
diff --git a/sdk-libs/macros/src/native_compressible.rs b/sdk-libs/macros/src/native_compressible.rs
@@ -404,7 +404,7 @@ fn generate_thin_processors(struct_names: &[&Ident]) -> Vec<Item> {
                     #(#variant_match_arms)*
                 };
 
-                let light_account = light_sdk::account::LightAccount::<'_, CompressedAccountVariant>::new_mut(
+                let light_account = light_sdk::account::sha::LightAccount::<'_, CompressedAccountVariant>::new_mut(
                     &crate::ID,
                     &compressed_data.meta,
                     unified_account.clone(),
diff --git a/sdk-libs/sdk/src/account.rs b/sdk-libs/sdk/src/account.rs
@@ -65,7 +65,10 @@
 //! ```
 // TODO: add example for manual hashing
 
-use std::ops::{Deref, DerefMut};
+use std::{
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+};
 
 use light_compressed_account::{
     compressed_account::PackedMerkleContext,
@@ -76,27 +79,40 @@ use solana_pubkey::Pubkey;
 
 use crate::{
     error::LightSdkError,
-    light_hasher::{DataHasher, Poseidon},
+    light_hasher::{DataHasher, Hasher, Poseidon, Sha256},
     AnchorDeserialize, AnchorSerialize, LightDiscriminator,
 };
 
 pub trait Size {
     fn size(&self) -> usize;
 }
 
+pub type LightAccount<'a, A> = LightAccountInner<'a, Poseidon, A>;
+
+pub mod sha {
+    use super::*;
+    /// LightAccount variant that uses SHA256 hashing
+    pub type LightAccount<'a, A> = super::LightAccountInner<'a, Sha256, A>;
+}
+
 #[derive(Debug, PartialEq)]
-pub struct LightAccount<
+pub struct LightAccountInner<
     'a,
+    H: Hasher,
     A: AnchorSerialize + AnchorDeserialize + LightDiscriminator + DataHasher + Default,
 > {
     owner: &'a Pubkey,
     pub account: A,
     account_info: CompressedAccountInfo,
     should_remove_data: bool,
+    _hasher: PhantomData<H>,
 }
 
-impl<'a, A: AnchorSerialize + AnchorDeserialize + LightDiscriminator + DataHasher + Default>
-    LightAccount<'a, A>
+impl<
+        'a,
+        H: Hasher,
+        A: AnchorSerialize + AnchorDeserialize + LightDiscriminator + DataHasher + Default,
+    > LightAccountInner<'a, H, A>
 {
     pub fn new_init(
         owner: &'a Pubkey,
@@ -117,6 +133,7 @@ impl<'a, A: AnchorSerialize + AnchorDeserialize + LightDiscriminator + DataHashe
                 output: Some(output_account_info),
             },
             should_remove_data: false,
+            _hasher: PhantomData,
         }
     }
 
@@ -126,7 +143,7 @@ impl<'a, A: AnchorSerialize + AnchorDeserialize + LightDiscriminator + DataHashe
         input_account: A,
     ) -> Result<Self, LightSdkError> {
         let input_account_info = {
-            let input_data_hash = input_account.hash::<Poseidon>()?;
+            let input_data_hash = input_account.hash::<H>()?;
             let tree_info = input_account_meta.get_tree_info();
             InAccountInfo {
                 data_hash: input_data_hash,
@@ -162,6 +179,7 @@ impl<'a, A: AnchorSerialize + AnchorDeserialize + LightDiscriminator + DataHashe
                 output: Some(output_account_info),
             },
             should_remove_data: false,
+            _hasher: PhantomData,
         })
     }
 
@@ -208,6 +226,7 @@ impl<'a, A: AnchorSerialize + AnchorDeserialize + LightDiscriminator + DataHashe
                 output: Some(output_account_info),
             },
             should_remove_data: false,
+            _hasher: PhantomData,
         })
     }
 
@@ -217,7 +236,7 @@ impl<'a, A: AnchorSerialize + AnchorDeserialize + LightDiscriminator + DataHashe
         input_account: A,
     ) -> Result<Self, LightSdkError> {
         let input_account_info = {
-            let input_data_hash = input_account.hash::<Poseidon>()?;
+            let input_data_hash = input_account.hash::<H>()?;
             let tree_info = input_account_meta.get_tree_info();
             InAccountInfo {
                 data_hash: input_data_hash,
@@ -241,6 +260,7 @@ impl<'a, A: AnchorSerialize + AnchorDeserialize + LightDiscriminator + DataHashe
                 output: None,
             },
             should_remove_data: false,
+            _hasher: PhantomData,
         })
     }
 
@@ -309,7 +329,10 @@ impl<'a, A: AnchorSerialize + AnchorDeserialize + LightDiscriminator + DataHashe
                 // TODO: review security.
                 output.data_hash = DEFAULT_DATA_HASH;
             } else {
-                output.data_hash = self.account.hash::<Poseidon>()?;
+                output.data_hash = self.account.hash::<H>()?;
+                if H::ID != 0 {
+                    output.data_hash[0] = 0;
+                }
                 output.data = self
                     .account
                     .try_to_vec()
diff --git a/sdk-libs/sdk/src/compressible/compress_account.rs b/sdk-libs/sdk/src/compressible/compress_account.rs
@@ -7,7 +7,7 @@ use solana_msg::msg;
 use solana_sysvar::Sysvar;
 
 use crate::{
-    account::LightAccount,
+    account::sha::LightAccount,
     compressible::{compress_account_on_init::close, compression_info::HasCompressionInfo},
     cpi::{CpiAccounts, CpiInputs},
     error::LightSdkError,
diff --git a/sdk-libs/sdk/src/compressible/compress_account_on_init.rs b/sdk-libs/sdk/src/compressible/compress_account_on_init.rs
@@ -9,7 +9,7 @@ use solana_msg::msg;
 use solana_pubkey::Pubkey;
 
 use crate::{
-    account::LightAccount,
+    account::sha::LightAccount,
     address::PackedNewAddressParams,
     compressible::HasCompressionInfo,
     cpi::{CpiAccounts, CpiInputs},
@@ -140,6 +140,7 @@ where
         // Ensure the account is marked as compressed We need to init first
         // because it's none. Setting to compressed prevents lamports funding
         // attack.
+
         *solana_account.compression_info_mut_opt() =
             Some(super::CompressionInfo::new_decompressed()?);
         solana_account.compression_info_mut().set_compressed();
diff --git a/sdk-libs/sdk/src/compressible/decompress_idempotent.rs b/sdk-libs/sdk/src/compressible/decompress_idempotent.rs
@@ -11,8 +11,8 @@ use solana_system_interface::instruction as system_instruction;
 use solana_sysvar::Sysvar;
 
 use crate::{
-    account::LightAccount, compressible::compression_info::HasCompressionInfo, cpi::CpiAccounts,
-    error::LightSdkError, AnchorDeserialize, AnchorSerialize, LightDiscriminator,
+    account::sha::LightAccount, compressible::compression_info::HasCompressionInfo,
+    cpi::CpiAccounts, error::LightSdkError, AnchorDeserialize, AnchorSerialize, LightDiscriminator,
 };
 
 /// Helper function to decompress multiple compressed accounts into PDAs
diff --git a/sdk-libs/sdk/src/lib.rs b/sdk-libs/sdk/src/lib.rs
@@ -104,6 +104,12 @@
 /// Compressed account abstraction similar to anchor Account.
 pub mod account;
 pub use account::LightAccount;
+
+/// SHA256-based variants
+pub mod sha {
+    pub use crate::account::sha::LightAccount;
+    pub use light_sdk_macros::LightHasherSha as LightHasher;
+}
 /// Functions to derive compressed account addresses.
 pub mod address;
 /// SDK helpers for compressing and decompressing PDAs.
diff --git a/sdk-tests/anchor-compressible/src/lib.rs b/sdk-tests/anchor-compressible/src/lib.rs
@@ -1,6 +1,6 @@
 use anchor_lang::{prelude::*, solana_program::pubkey::Pubkey};
 use light_sdk::{
-    account::{LightAccount, Size},
+    account::Size,
     compressible::{
         compress_account, compress_account_on_init, prepare_accounts_for_compression_on_init,
         prepare_accounts_for_decompress_idempotent, process_initialize_compression_config_checked,
@@ -10,6 +10,7 @@ use light_sdk::{
     derive_light_cpi_signer,
     instruction::{account_meta::CompressedAccountMeta, PackedAddressTreeInfo, ValidityProof},
     light_hasher::{DataHasher, Hasher},
+    sha::LightAccount,
     LightDiscriminator, LightHasher,
 };
 use light_sdk_types::CpiSigner;
@@ -173,7 +174,7 @@ pub mod anchor_compressible {
                     }
                     seeds_refs.push(&bump_slice);
 
-                    // Create LightAccount with correct UserRecord discriminator
+                    // Create sha::LightAccount with correct UserRecord discriminator
                     let light_account = LightAccount::<'_, UserRecord>::new_mut(
                         &crate::ID,
                         &compressed_data.meta,
@@ -200,7 +201,7 @@ pub mod anchor_compressible {
                     }
                     seeds_refs.push(&bump_slice);
 
-                    // Create LightAccount with correct GameSession discriminator
+                    // Create sha::LightAccount with correct GameSession discriminator
                     let light_account = LightAccount::<'_, GameSession>::new_mut(
                         &crate::ID,
                         &compressed_data.meta,
diff --git a/sdk-tests/native-compressible/src/decompress_dynamic_pda.rs b/sdk-tests/native-compressible/src/decompress_dynamic_pda.rs
@@ -1,6 +1,6 @@
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_sdk::{
-    account::LightAccount,
+    account::sha::LightAccount,
     compressible::{prepare_accounts_for_decompress_idempotent, CompressibleConfig},
     cpi::{CpiAccounts, CpiInputs},
     error::LightSdkError,
diff --git a/sdk-tests/native-compressible/src/lib.rs b/sdk-tests/native-compressible/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@ use crate::{`
`9`	`9`	`pub struct Keccak;`
`10`	`10`
`11`	`11`	`impl Hasher for Keccak {`
	`12`	`+ const ID: u8 = 2;`
	`13`	`+`
`12`	`14`	`fn hash(val: &[u8]) -> Result<Hash, HasherError> {`
`13`	`15`	`Self::hashv(&[val])`
`14`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,6 +78,8 @@ impl From<PoseidonSyscallError> for u64 {`
`78`	`78`	`pub struct Poseidon;`
`79`	`79`
`80`	`80`	`impl Hasher for Poseidon {`
	`81`	`+ const ID: u8 = 0;`
	`82`	`+`
`81`	`83`	`fn hash(val: &[u8]) -> Result<Hash, HasherError> {`
`82`	`84`	`Self::hashv(&[val])`
`83`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ use crate::{`
`9`	`9`	`pub struct Sha256;`
`10`	`10`
`11`	`11`	`impl Hasher for Sha256 {`
	`12`	`+ const ID: u8 = 1;`
`12`	`13`	`fn hash(val: &[u8]) -> Result<Hash, HasherError> {`
`13`	`14`	`Self::hashv(&[val])`
`14`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,14 @@ pub(crate) fn generate_data_hasher_impl(`
`37`	`37`	`slices[num_flattned_fields] = element.as_slice();`
`38`	`38`	`}`
`39`	`39`
`40`		`- H::hashv(slices.as_slice())`
	`40`	`+ let mut result = H::hashv(slices.as_slice())?;`
	`41`	`+`
	`42`	`+ // Apply field size truncation for non-Poseidon hashers`
	`43`	`+ if H::ID != 0 {`
	`44`	`+ result[0] = 0;`
	`45`	`+ }`
	`46`	`+`
	`47`	`+ Ok(result)`
`41`	`48`	`}`
`42`	`49`	`}`
`43`	`50`	`}`
`@@ -59,9 +66,16 @@ pub(crate) fn generate_data_hasher_impl(`
`59`	`66`	`println!("DataHasher::hash inputs {:?}", debug_prints);`
`60`	`67`	`}`
`61`	`68`	`}`
`62`		`- H::hashv(&[`
	`69`	`+ let mut result = H::hashv(&[`
`63`	`70`	`#(#data_hasher_assignments.as_slice(),)*`
`64`		`- ])`
	`71`	`+ ])?;`
	`72`	`+`
	`73`	`+ // Apply field size truncation for non-Poseidon hashers`
	`74`	`+ if H::ID != 0 {`
	`75`	`+ result[0] = 0;`
	`76`	`+ }`
	`77`	`+`
	`78`	`+ Ok(result)`
`65`	`79`	`}`
`66`	`80`	`}`
`67`	`81`	`}`