Add bpf target to hashers (#396)

febo · web-flow · commit 857c2b16e98c · 2025-10-29T17:21:13.000Z
* Add target_arch bpf

* Tweaks

* Fix clippy

* More target_arch bpf support

* Re-export syscall
diff --git a/blake3-hasher/Cargo.toml b/blake3-hasher/Cargo.toml
@@ -20,12 +20,12 @@ blake3 = ["dep:blake3"]
 [dependencies]
 solana-hash = { workspace = true, features = ["decode"] }
 
-[target.'cfg(not(target_os = "solana"))'.dependencies]
-blake3 = { workspace = true, optional = true }
-
-[target.'cfg(target_os = "solana")'.dependencies]
+[target.'cfg(any(target_os = "solana", target_arch = "bpf"))'.dependencies]
 solana-define-syscall = { workspace = true }
 
+[target.'cfg(not(any(target_os = "solana", target_arch = "bpf")))'.dependencies]
+blake3 = { workspace = true, optional = true }
+
 [dev-dependencies]
 solana-blake3-hasher = { path = ".", features = ["blake3"] }
 
diff --git a/blake3-hasher/src/lib.rs b/blake3-hasher/src/lib.rs
@@ -1,18 +1,24 @@
 //! Hashing with the [blake3] hash function.
 //!
 //! [blake3]: https://github.com/BLAKE3-team/BLAKE3
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![no_std]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 
 pub use solana_hash::{Hash, ParseHashError, HASH_BYTES, MAX_BASE58_LEN};
 
 #[derive(Clone, Default)]
-#[cfg(all(feature = "blake3", not(target_os = "solana")))]
+#[cfg(all(
+    feature = "blake3",
+    not(any(target_os = "solana", target_arch = "bpf"))
+))]
 pub struct Hasher {
     hasher: blake3::Hasher,
 }
 
-#[cfg(all(feature = "blake3", not(target_os = "solana")))]
+#[cfg(all(
+    feature = "blake3",
+    not(any(target_os = "solana", target_arch = "bpf"))
+))]
 impl Hasher {
     pub fn hash(&mut self, val: &[u8]) {
         self.hasher.update(val);
@@ -28,11 +34,11 @@ impl Hasher {
 }
 
 /// Return a Blake3 hash for the given data.
-#[cfg_attr(target_os = "solana", inline(always))]
+#[cfg_attr(any(target_os = "solana", target_arch = "bpf"), inline(always))]
 pub fn hashv(vals: &[&[u8]]) -> Hash {
     // Perform the calculation inline, calling this from within a program is
     // not supported
-    #[cfg(not(target_os = "solana"))]
+    #[cfg(not(any(target_os = "solana", target_arch = "bpf")))]
     {
         #[cfg(feature = "blake3")]
         {
@@ -47,7 +53,7 @@ pub fn hashv(vals: &[&[u8]]) -> Hash {
         }
     }
     // Call via a system call to perform the calculation
-    #[cfg(target_os = "solana")]
+    #[cfg(any(target_os = "solana", target_arch = "bpf"))]
     {
         let mut hash_result = core::mem::MaybeUninit::<[u8; solana_hash::HASH_BYTES]>::uninit();
         // SAFETY: This is sound as sol_blake3 always fills all 32 bytes of our hash
@@ -63,7 +69,7 @@ pub fn hashv(vals: &[&[u8]]) -> Hash {
 }
 
 /// Return a Blake3 hash for the given data.
-#[cfg_attr(target_os = "solana", inline(always))]
+#[cfg_attr(any(target_os = "solana", target_arch = "bpf"), inline(always))]
 pub fn hash(val: &[u8]) -> Hash {
     hashv(&[val])
 }
diff --git a/keccak-hasher/Cargo.toml b/keccak-hasher/Cargo.toml
@@ -20,11 +20,11 @@ sha3 = ["dep:sha3"]
 [dependencies]
 solana-hash = { workspace = true, features = ["decode"] }
 
-[target.'cfg(not(target_os = "solana"))'.dependencies]
-sha3 = { workspace = true, optional = true }
-
-[target.'cfg(target_os = "solana")'.dependencies]
+[target.'cfg(any(target_os = "solana", target_arch = "bpf"))'.dependencies]
 solana-define-syscall = { workspace = true }
 
+[target.'cfg(not(any(target_os = "solana", target_arch = "bpf")))'.dependencies]
+sha3 = { workspace = true, optional = true }
+
 [lints]
 workspace = true
diff --git a/keccak-hasher/src/lib.rs b/keccak-hasher/src/lib.rs
@@ -1,20 +1,20 @@
 //! Hashing with the [keccak] (SHA-3) hash function.
 //!
 //! [keccak]: https://keccak.team/keccak.html
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![no_std]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 
-#[cfg(all(feature = "sha3", not(target_os = "solana")))]
+#[cfg(all(feature = "sha3", not(any(target_os = "solana", target_arch = "bpf"))))]
 use sha3::{Digest, Keccak256};
 pub use solana_hash::{Hash, ParseHashError, HASH_BYTES, MAX_BASE58_LEN};
 
 #[derive(Clone, Default)]
-#[cfg(all(feature = "sha3", not(target_os = "solana")))]
+#[cfg(all(feature = "sha3", not(any(target_os = "solana", target_arch = "bpf"))))]
 pub struct Hasher {
     hasher: Keccak256,
 }
 
-#[cfg(all(feature = "sha3", not(target_os = "solana")))]
+#[cfg(all(feature = "sha3", not(any(target_os = "solana", target_arch = "bpf"))))]
 impl Hasher {
     pub fn hash(&mut self, val: &[u8]) {
         self.hasher.update(val);
@@ -30,11 +30,11 @@ impl Hasher {
 }
 
 /// Return a Keccak256 hash for the given data.
-#[cfg_attr(target_os = "solana", inline(always))]
+#[cfg_attr(any(target_os = "solana", target_arch = "bpf"), inline(always))]
 pub fn hashv(vals: &[&[u8]]) -> Hash {
     // Perform the calculation inline, calling this from within a program is
     // not supported
-    #[cfg(not(target_os = "solana"))]
+    #[cfg(not(any(target_os = "solana", target_arch = "bpf")))]
     {
         #[cfg(feature = "sha3")]
         {
@@ -49,7 +49,7 @@ pub fn hashv(vals: &[&[u8]]) -> Hash {
         }
     }
     // Call via a system call to perform the calculation
-    #[cfg(target_os = "solana")]
+    #[cfg(any(target_os = "solana", target_arch = "bpf"))]
     {
         let mut hash_result = core::mem::MaybeUninit::<[u8; solana_hash::HASH_BYTES]>::uninit();
         // SAFETY: This is sound as sol_keccak256 always fills all 32 bytes of our hash
@@ -65,7 +65,7 @@ pub fn hashv(vals: &[&[u8]]) -> Hash {
 }
 
 /// Return a Keccak256 hash for the given data.
-#[cfg_attr(target_os = "solana", inline(always))]
+#[cfg_attr(any(target_os = "solana", target_arch = "bpf"), inline(always))]
 pub fn hash(val: &[u8]) -> Hash {
     hashv(&[val])
 }
diff --git a/scripts/check-no-std.sh b/scripts/check-no-std.sh
@@ -10,13 +10,15 @@ cd "${src_root}"
 no_std_crates=(
   -p solana-address
   -p solana-account-view
+  -p solana-blake3-hasher
   -p solana-clock
   -p solana-commitment-config
   -p solana-define-syscall
   -p solana-epoch-info
   -p solana-epoch-rewards
   -p solana-fee-calculator
   -p solana-hash
+  -p solana-keccak-hasher
   -p solana-msg
   -p solana-program-error
   -p solana-program-log
diff --git a/secp256k1-recover/Cargo.toml b/secp256k1-recover/Cargo.toml
@@ -26,12 +26,12 @@ solana-frozen-abi-macro = { workspace = true, optional = true, features = [
 ] }
 thiserror = { workspace = true }
 
-[target.'cfg(not(target_os = "solana"))'.dependencies]
-k256 = { workspace = true }
-
-[target.'cfg(target_os = "solana")'.dependencies]
+[target.'cfg(any(target_os = "solana", target_arch = "bpf"))'.dependencies]
 solana-define-syscall = { workspace = true }
 
+[target.'cfg(not(any(target_os = "solana", target_arch = "bpf")))'.dependencies]
+k256 = { workspace = true }
+
 [dev-dependencies]
 anyhow = { workspace = true }
 borsh = { workspace = true }
diff --git a/secp256k1-recover/src/lib.rs b/secp256k1-recover/src/lib.rs
@@ -87,7 +87,7 @@ impl Secp256k1Pubkey {
     }
 }
 
-#[cfg(target_os = "solana")]
+#[cfg(any(target_os = "solana", target_arch = "bpf"))]
 pub use solana_define_syscall::definitions::sol_secp256k1_recover;
 
 /// Recover the public key from a [secp256k1] ECDSA signature and
@@ -402,13 +402,13 @@ pub use solana_define_syscall::definitions::sol_secp256k1_recover;
 ///     Ok(())
 /// }
 /// ```
-#[cfg_attr(target_os = "solana", inline(always))]
+#[cfg_attr(any(target_os = "solana", target_arch = "bpf"), inline(always))]
 pub fn secp256k1_recover(
     hash: &[u8],
     recovery_id: u8,
     signature: &[u8],
 ) -> Result<Secp256k1Pubkey, Secp256k1RecoverError> {
-    #[cfg(target_os = "solana")]
+    #[cfg(any(target_os = "solana", target_arch = "bpf"))]
     {
         let mut pubkey_buffer =
             core::mem::MaybeUninit::<[u8; SECP256K1_PUBLIC_KEY_LENGTH]>::uninit();
@@ -421,14 +421,15 @@ pub fn secp256k1_recover(
             )
         };
 
-        // SAFETY: This is sound as in our pass case, all 64 bytes of the pubkey are always initialized by sol_secp256k1_recover
+        // SAFETY: This is sound as in our pass case, all 64 bytes of the pubkey are
+        // always initialized by sol_secp256k1_recover
         match result {
             0 => Ok(Secp256k1Pubkey(unsafe { pubkey_buffer.assume_init() })),
             error => Err(Secp256k1RecoverError::from(error)),
         }
     }
 
-    #[cfg(not(target_os = "solana"))]
+    #[cfg(not(any(target_os = "solana", target_arch = "bpf")))]
     {
         const HASH_SIZE: usize = 32;
         if hash.len() != HASH_SIZE {
diff --git a/sha256-hasher/Cargo.toml b/sha256-hasher/Cargo.toml
@@ -18,12 +18,12 @@ sha2 = ["dep:sha2"]
 [dependencies]
 solana-hash = { workspace = true }
 
-[target.'cfg(not(target_os = "solana"))'.dependencies]
-sha2 = { workspace = true, optional = true }
-
-[target.'cfg(target_os = "solana")'.dependencies]
+[target.'cfg(any(target_os = "solana", target_arch = "bpf"))'.dependencies]
 solana-define-syscall = { workspace = true }
 
+[target.'cfg(not(any(target_os = "solana", target_arch = "bpf")))'.dependencies]
+sha2 = { workspace = true, optional = true }
+
 [dev-dependencies]
 solana-sha256-hasher = { path = ".", features = ["sha2"] }
 
diff --git a/sha256-hasher/src/lib.rs b/sha256-hasher/src/lib.rs
@@ -1,16 +1,24 @@
 #![no_std]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
-#[cfg(all(feature = "sha2", not(target_os = "solana")))]
-use sha2::{Digest, Sha256};
+
+#[cfg(any(target_os = "solana", target_arch = "bpf"))]
+pub use solana_define_syscall::definitions::sol_sha256;
 use solana_hash::Hash;
+#[cfg(any(target_os = "solana", target_arch = "bpf"))]
+use {core::mem::MaybeUninit, solana_hash::HASH_BYTES};
+#[cfg(all(feature = "sha2", not(any(target_os = "solana", target_arch = "bpf"))))]
+use {
+    sha2::{Digest, Sha256},
+    solana_hash::HASH_BYTES,
+};
 
-#[cfg(all(feature = "sha2", not(target_os = "solana")))]
+#[cfg(all(feature = "sha2", not(any(target_os = "solana", target_arch = "bpf"))))]
 #[derive(Clone, Default)]
 pub struct Hasher {
     hasher: Sha256,
 }
 
-#[cfg(all(feature = "sha2", not(target_os = "solana")))]
+#[cfg(all(feature = "sha2", not(any(target_os = "solana", target_arch = "bpf"))))]
 impl Hasher {
     pub fn hash(&mut self, val: &[u8]) {
         self.hasher.update(val);
@@ -21,20 +29,17 @@ impl Hasher {
         }
     }
     pub fn result(self) -> Hash {
-        let bytes: [u8; solana_hash::HASH_BYTES] = self.hasher.finalize().into();
+        let bytes: [u8; HASH_BYTES] = self.hasher.finalize().into();
         bytes.into()
     }
 }
 
-#[cfg(target_os = "solana")]
-pub use solana_define_syscall::definitions::sol_sha256;
-
 /// Return a Sha256 hash for the given data.
 #[cfg_attr(target_os = "solana", inline(always))]
 pub fn hashv(vals: &[&[u8]]) -> Hash {
     // Perform the calculation inline, calling this from within a program is
     // not supported
-    #[cfg(not(target_os = "solana"))]
+    #[cfg(not(any(target_os = "solana", target_arch = "bpf")))]
     {
         #[cfg(feature = "sha2")]
         {
@@ -49,9 +54,9 @@ pub fn hashv(vals: &[&[u8]]) -> Hash {
         }
     }
     // Call via a system call to perform the calculation
-    #[cfg(target_os = "solana")]
+    #[cfg(any(target_os = "solana", target_arch = "bpf"))]
     {
-        let mut hash_result = core::mem::MaybeUninit::<[u8; solana_hash::HASH_BYTES]>::uninit();
+        let mut hash_result = MaybeUninit::<[u8; HASH_BYTES]>::uninit();
         // SAFETY: This is sound as sol_sha256 always fills all 32 bytes of our hash
         unsafe {
             sol_sha256(

Original file line number	Diff line number	Diff line change
`@@ -1,20 +1,20 @@`
`1`	`1`	`//! Hashing with the [keccak] (SHA-3) hash function.`
`2`	`2`	`//!`
`3`	`3`	`//! [keccak]: https://keccak.team/keccak.html`
`4`		`-#![cfg_attr(docsrs, feature(doc_auto_cfg))]`
`5`	`4`	`#![no_std]`
	`5`	`+#![cfg_attr(docsrs, feature(doc_auto_cfg))]`
`6`	`6`
`7`		`-#[cfg(all(feature = "sha3", not(target_os = "solana")))]`
	`7`	`+#[cfg(all(feature = "sha3", not(any(target_os = "solana", target_arch = "bpf"))))]`
`8`	`8`	`use sha3::{Digest, Keccak256};`
`9`	`9`	`pub use solana_hash::{Hash, ParseHashError, HASH_BYTES, MAX_BASE58_LEN};`
`10`	`10`
`11`	`11`	`#[derive(Clone, Default)]`
`12`		`-#[cfg(all(feature = "sha3", not(target_os = "solana")))]`
	`12`	`+#[cfg(all(feature = "sha3", not(any(target_os = "solana", target_arch = "bpf"))))]`
`13`	`13`	`pub struct Hasher {`
`14`	`14`	`hasher: Keccak256,`
`15`	`15`	`}`
`16`	`16`
`17`		`-#[cfg(all(feature = "sha3", not(target_os = "solana")))]`
	`17`	`+#[cfg(all(feature = "sha3", not(any(target_os = "solana", target_arch = "bpf"))))]`
`18`	`18`	`impl Hasher {`
`19`	`19`	`pub fn hash(&mut self, val: &[u8]) {`
`20`	`20`	`self.hasher.update(val);`
`@@ -30,11 +30,11 @@ impl Hasher {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`/// Return a Keccak256 hash for the given data.`
`33`		`-#[cfg_attr(target_os = "solana", inline(always))]`
	`33`	`+#[cfg_attr(any(target_os = "solana", target_arch = "bpf"), inline(always))]`
`34`	`34`	`pub fn hashv(vals: &[&[u8]]) -> Hash {`
`35`	`35`	`// Perform the calculation inline, calling this from within a program is`
`36`	`36`	`// not supported`
`37`		`- #[cfg(not(target_os = "solana"))]`
	`37`	`+ #[cfg(not(any(target_os = "solana", target_arch = "bpf")))]`
`38`	`38`	`{`
`39`	`39`	`#[cfg(feature = "sha3")]`
`40`	`40`	`{`
`@@ -49,7 +49,7 @@ pub fn hashv(vals: &[&[u8]]) -> Hash {`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`// Call via a system call to perform the calculation`
`52`		`- #[cfg(target_os = "solana")]`
	`52`	`+ #[cfg(any(target_os = "solana", target_arch = "bpf"))]`
`53`	`53`	`{`
`54`	`54`	`let mut hash_result = core::mem::MaybeUninit::<[u8; solana_hash::HASH_BYTES]>::uninit();`
`55`	`55`	`// SAFETY: This is sound as sol_keccak256 always fills all 32 bytes of our hash`
`@@ -65,7 +65,7 @@ pub fn hashv(vals: &[&[u8]]) -> Hash {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`/// Return a Keccak256 hash for the given data.`
`68`		`-#[cfg_attr(target_os = "solana", inline(always))]`
	`68`	`+#[cfg_attr(any(target_os = "solana", target_arch = "bpf"), inline(always))]`
`69`	`69`	`pub fn hash(val: &[u8]) -> Hash {`
`70`	`70`	`hashv(&[val])`
`71`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ impl Secp256k1Pubkey {`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`90`		`-#[cfg(target_os = "solana")]`
	`90`	`+#[cfg(any(target_os = "solana", target_arch = "bpf"))]`
`91`	`91`	`pub use solana_define_syscall::definitions::sol_secp256k1_recover;`
`92`	`92`
`93`	`93`	`/// Recover the public key from a [secp256k1] ECDSA signature and`
`@@ -402,13 +402,13 @@ pub use solana_define_syscall::definitions::sol_secp256k1_recover;`
`402`	`402`	`/// Ok(())`
`403`	`403`	`/// }`
`404`	`404`	/// ```
`405`		`-#[cfg_attr(target_os = "solana", inline(always))]`
	`405`	`+#[cfg_attr(any(target_os = "solana", target_arch = "bpf"), inline(always))]`
`406`	`406`	`pub fn secp256k1_recover(`
`407`	`407`	`hash: &[u8],`
`408`	`408`	`recovery_id: u8,`
`409`	`409`	`signature: &[u8],`
`410`	`410`	`) -> Result<Secp256k1Pubkey, Secp256k1RecoverError> {`
`411`		`- #[cfg(target_os = "solana")]`
	`411`	`+ #[cfg(any(target_os = "solana", target_arch = "bpf"))]`
`412`	`412`	`{`
`413`	`413`	`let mut pubkey_buffer =`
`414`	`414`	`core::mem::MaybeUninit::<[u8; SECP256K1_PUBLIC_KEY_LENGTH]>::uninit();`
`@@ -421,14 +421,15 @@ pub fn secp256k1_recover(`
`421`	`421`	`)`
`422`	`422`	`};`
`423`	`423`
`424`		`- // SAFETY: This is sound as in our pass case, all 64 bytes of the pubkey are always initialized by sol_secp256k1_recover`
	`424`	`+ // SAFETY: This is sound as in our pass case, all 64 bytes of the pubkey are`
	`425`	`+ // always initialized by sol_secp256k1_recover`
`425`	`426`	`match result {`
`426`	`427`	`0 => Ok(Secp256k1Pubkey(unsafe { pubkey_buffer.assume_init() })),`
`427`	`428`	`error => Err(Secp256k1RecoverError::from(error)),`
`428`	`429`	`}`
`429`	`430`	`}`
`430`	`431`
`431`		`- #[cfg(not(target_os = "solana"))]`
	`432`	`+ #[cfg(not(any(target_os = "solana", target_arch = "bpf")))]`
`432`	`433`	`{`
`433`	`434`	`const HASH_SIZE: usize = 32;`
`434`	`435`	`if hash.len() != HASH_SIZE {`