Merge pull request #8 from yugocabrio/feat/hash-trait

feat: transcript hash trait

Author: yugocabrio

.github/workflows/ci.yml

@@ -49,8 +49,8 @@ jobs:
       - name: Run tests (std)
         run: cargo test --features std --verbose
 
-      - name: Run tests (soroban-bn254-precompile)
-        run: cargo test --features soroban-bn254-precompile --verbose
+      - name: Run tests (soroban-precompile)
+        run: cargo test --features soroban-precompile --verbose
 
-      - name: Run tests (std + soroban-bn254-precompile)
-        run: cargo test --features "std soroban-bn254-precompile" --verbose
+      - name: Run tests (std + soroban-precompile)
+        run: cargo test --features "std soroban-precompile" --verbose

Cargo.toml

@@ -29,7 +29,7 @@ once_cell = { version = "1.19", default-features = false, features = ["alloc", "
 [features]
 default = ["alloc", "serde", "serde_json"]
 # Soroban BN254 precompile integration switch
-soroban-bn254-precompile = []
+soroban-precompile = []
 std = [
     "sha3/std",
     "ark-ff/std",

README.md

@@ -60,13 +60,13 @@ Notes:
 - `std`: enables I/O and serde for convenient loading.
 - `trace`: prints detailed verifier internals (for debugging); off by default.
 - `alloc` (default): required for `no_std` collections.
-- `soroban-bn254-precompile`: routes MSM + pairing calls through a backend facade intended for a Soroban BN254 precompile.
+- `soroban-precompile`: routes MSM + pairing calls through a backend facade intended for a Soroban host precompile.
   For now, it falls back to Arkworks so behavior is unchanged, but gives a stable call site to switch to host calls later.
 
-### Soroban BN254 precompile
-- Purpose: Provide a seam to swap the EC hot paths (G1 MSM and pairing) to a Soroban BN254 precompile.
-- Enable: `--features soroban-bn254-precompile`. If no backend is registered, it transparently falls back to the Arkworks implementation.
-- Scope: Public API remains unchanged (`ec::g1_msm`, `ec::pairing_check`). Register a backend once at startup.
+### Soroban precompile
+- Purpose: Provide seams to swap the EC hot paths (G1 MSM and pairing) and the transcript hash to Soroban host precompiles.
+- Enable: `--features soroban-precompile`. If no backend is registered, it transparently falls back to the Arkworks/Keccak implementations.
+- Scope: Public API remains unchanged (`ec::g1_msm`, `ec::pairing_check`, `hash::hash32`). Register backends once during contract initialization.
 
 Backend contract
 - Trait: `ec::Bn254Ops` (intended to be `Send + Sync`)
@@ -76,14 +76,19 @@ Backend contract
     - Must verify `e(p0, rhs_g2) * e(p1, lhs_g2) == 1` using the fixed G2 constants defined in `ec.rs`.
 
 ```
-#[cfg(feature = "soroban-bn254-precompile")]
+#[cfg(feature = "soroban-precompile")]
 {
-    use ultrahonk_rust_verifier::{ec::{self, Bn254Ops}, types::G1Point, field::Fr};
+    use ultrahonk_rust_verifier::{
+        ec::{self, Bn254Ops},
+        hash::{self, HashOps},
+        types::G1Point,
+        field::Fr,
+    };
     use ark_bn254::G1Affine;
 
     // Example backend that calls the Soroban host precompile (pseudo-code)
-    struct SorobanOps { /* env: soroban_sdk::Env, ... */ }
-    impl Bn254Ops for SorobanOps {
+    struct SorobanEcOps { /* env: soroban_sdk::Env, ... */ }
+    impl Bn254Ops for SorobanEcOps {
         fn g1_msm(&self, coms: &[G1Point], scalars: &[Fr]) -> Result<G1Affine, String> {
             // host_msm(env, coms, scalars).map_err(|e| e.to_string())
             unimplemented!("call Soroban MSM precompile")
@@ -93,8 +98,16 @@ Backend contract
             unimplemented!("call Soroban pairing precompile")
         }
     }
+    struct SorobanHashOps { /* env, ... */ }
+    impl HashOps for SorobanHashOps {
+        fn hash(&self, data: &[u8]) -> [u8; 32] {
+            // host_poseidon(env, data)
+            unimplemented!("call Soroban hash precompile")
+        }
+    }
 
-    ec::set_soroban_bn254_backend(Box::new(SorobanOps { /* env, ... */ }));
+    ec::set_soroban_bn254_backend(Box::new(SorobanEcOps { /* env, ... */ }));
+    hash::set_soroban_hash_backend(Box::new(SorobanHashOps { /* env, ... */ }));
 }
 ```
 

src/ec.rs

@@ -12,7 +12,7 @@ use ark_ec::{pairing::Pairing, CurveGroup, PrimeGroup};
 use ark_ff::BigInteger;
 use ark_ff::{One, PrimeField, Zero};
 
-#[cfg(feature = "soroban-bn254-precompile")]
+#[cfg(feature = "soroban-precompile")]
 use once_cell::race::OnceBox;
 
 /// Trait for BN254 operations used by the verifier hot paths.
@@ -158,15 +158,15 @@ impl Bn254Ops for ArkworksOps {
 
 static ARKWORKS: ArkworksOps = ArkworksOps;
 
-#[cfg(feature = "soroban-bn254-precompile")]
+#[cfg(feature = "soroban-precompile")]
 struct BackendHolder(pub Box<dyn Bn254Ops + Send + Sync>);
 
-#[cfg(feature = "soroban-bn254-precompile")]
+#[cfg(feature = "soroban-precompile")]
 static BACKEND: OnceBox<BackendHolder> = OnceBox::new();
 
 #[inline(always)]
 fn backend() -> &'static dyn Bn254Ops {
-    #[cfg(feature = "soroban-bn254-precompile")]
+    #[cfg(feature = "soroban-precompile")]
     {
         if let Some(b) = BACKEND.get() {
             return &*b.0;
@@ -199,13 +199,13 @@ pub mod helpers {
     }
 }
 
-#[cfg(feature = "soroban-bn254-precompile")]
+#[cfg(feature = "soroban-precompile")]
 /// Register a custom BN254 backend (Soroban BN254 precompile bridge).
 pub fn set_backend(ops: Box<dyn Bn254Ops + Send + Sync>) {
     let _ = BACKEND.set(Box::new(BackendHolder(ops)));
 }
 
-#[cfg(feature = "soroban-bn254-precompile")]
+#[cfg(feature = "soroban-precompile")]
 #[inline(always)]
 pub fn set_soroban_bn254_backend(ops: Box<dyn Bn254Ops + Send + Sync>) {
     set_backend(ops)

src/hash.rs

@@ -1,11 +1,62 @@
 use sha3::{Digest, Keccak256};
 
-/// Compute Keccak-256 hash of the given data, returning a 32-byte array.
-pub fn keccak256(data: &[u8]) -> [u8; 32] {
-    let mut hasher = Keccak256::new();
-    hasher.update(data);
-    let result = hasher.finalize();
-    let mut out = [0u8; 32];
-    out.copy_from_slice(&result);
-    out
+#[cfg(all(feature = "soroban-precompile", not(feature = "std")))]
+use alloc::boxed::Box;
+#[cfg(all(feature = "soroban-precompile", feature = "std"))]
+use std::boxed::Box;
+
+#[cfg(feature = "soroban-precompile")]
+use once_cell::race::OnceBox;
+
+/// Transcript hash backend abstraction trait.
+pub trait HashOps: Send + Sync {
+    fn hash(&self, data: &[u8]) -> [u8; 32];
+}
+
+pub struct KeccakBackend;
+
+impl HashOps for KeccakBackend {
+    #[inline(always)]
+    fn hash(&self, data: &[u8]) -> [u8; 32] {
+        let mut hasher = Keccak256::new();
+        hasher.update(data);
+        let result = hasher.finalize();
+        let mut out = [0u8; 32];
+        out.copy_from_slice(&result);
+        out
+    }
+}
+
+static KECCAK_BACKEND: KeccakBackend = KeccakBackend;
+
+#[cfg(feature = "soroban-precompile")]
+static BACKEND: OnceBox<Box<dyn HashOps>> = OnceBox::new();
+
+#[inline(always)]
+fn backend() -> &'static dyn HashOps {
+    #[cfg(feature = "soroban-precompile")]
+    {
+        if let Some(b) = BACKEND.get() {
+            return &**b;
+        }
+    }
+    &KECCAK_BACKEND
+}
+
+/// Compute the active backend hash of the given data
+#[inline(always)]
+pub fn hash32(data: &[u8]) -> [u8; 32] {
+    backend().hash(data)
+}
+
+#[cfg(feature = "soroban-precompile")]
+/// Register a custom hash backend (Soroban precompile bridge).
+pub fn set_backend(ops: Box<dyn HashOps>) {
+    let _ = BACKEND.set(Box::new(ops));
+}
+
+#[cfg(feature = "soroban-precompile")]
+#[inline(always)]
+pub fn set_soroban_hash_backend(ops: Box<dyn HashOps>) {
+    set_backend(ops)
 }

src/transcript.rs

@@ -3,7 +3,7 @@
 use crate::trace;
 use crate::{
     field::Fr,
-    hash::keccak256,
+    hash::hash32,
     types::{Proof, RelationParameters, Transcript, CONST_PROOF_SIZE_LOG_N},
 };
 use ark_bn254::G1Affine;
@@ -33,7 +33,7 @@ fn split(fr: Fr) -> (Fr, Fr) {
 
 #[inline(always)]
 fn hash_to_fr(bytes: &[u8]) -> Fr {
-    Fr::from_bytes(&keccak256(bytes))
+    Fr::from_bytes(&hash32(bytes))
 }
 
 fn u64_to_be32(x: u64) -> [u8; 32] {