Add commit_single to ProvingSystem trait and device_memory_id getter

- Add ProvingSystem::commit_single() method that returns serialized
  commitment bytes for Fiat-Shamir transcript hashing in two-round
  LogUp binding protocol
- Implement for Expander, ExpanderLocalDeferred, DummyProvingSystem
  (real commit), and stub for remote backends
- Add DeviceMemoryHandleRaw::device_memory_id() public getter

These changes support the cross-kernel bus binding security fix
in KlawdVM where LogUp bus messages must be cryptographically
bound to committed witness polynomials.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hczphn

expander_compiler/src/zkcuda/context.rs

@@ -36,6 +36,13 @@ pub struct DeviceMemoryHandleRaw {
     shape_history: ShapeHistory,
 }
 
+impl DeviceMemoryHandleRaw {
+    /// Returns the device memory index (position in the device_memories vector).
+    pub fn device_memory_id(&self) -> usize {
+        self.id
+    }
+}
+
 pub type DeviceMemoryHandle = Option<DeviceMemoryHandleRaw>;
 
 #[derive(Clone, ExpSerde)]

expander_compiler/src/zkcuda/proving_system/dummy.rs

@@ -215,6 +215,17 @@ impl<C: Config> ProvingSystem<C> for DummyProvingSystem<C> {
         verified.iter().all(|x| *x)
     }
 
+    fn commit_single(
+        prover_setup: &Self::ProverSetup,
+        device_memory: &[SIMDField<C>],
+    ) -> Vec<u8> {
+        let (commitment, _state) =
+            <Self as KernelWiseProvingSystem<C>>::commit(prover_setup, device_memory);
+        let mut buf = Vec::new();
+        serdes::ExpSerde::serialize_into(&commitment, &mut buf).expect("commitment serialization");
+        buf
+    }
+
     fn post_process() {
         <Self as KernelWiseProvingSystem<C>>::post_process();
     }

expander_compiler/src/zkcuda/proving_system/expander/api_single_thread.rs

@@ -256,6 +256,17 @@ impl<C: GKREngine, ECCConfig: Config<FieldConfig = C::FieldConfig>> ProvingSyste
         verified.iter().all(|x| *x)
     }
 
+    fn commit_single(
+        prover_setup: &Self::ProverSetup,
+        device_memory: &[SIMDField<ECCConfig>],
+    ) -> Vec<u8> {
+        let (commitment, _state) =
+            <Self as KernelWiseProvingSystem<ECCConfig>>::commit(prover_setup, device_memory);
+        let mut buf = Vec::new();
+        serdes::ExpSerde::serialize_into(&commitment, &mut buf).expect("commitment serialization");
+        buf
+    }
+
     fn post_process() {
         <Self as KernelWiseProvingSystem<ECCConfig>>::post_process();
     }

expander_compiler/src/zkcuda/proving_system/expander_local_deferred/api.rs

@@ -71,6 +71,19 @@ impl<C: GKREngine, ECCConfig: Config<FieldConfig = C::FieldConfig>> ProvingSyste
         CombinedProof { commitments, proofs }
     }
 
+    fn commit_single(
+        ps: &Self::ProverSetup,
+        device_memory: &[SIMDField<ECCConfig>],
+    ) -> Vec<u8> {
+        use crate::zkcuda::proving_system::expander::commit_impl::local_commit_impl;
+        let (commitment, _state) = local_commit_impl::<C, ECCConfig>(
+            ps.p_keys.get(&device_memory.len()).unwrap(), device_memory,
+        );
+        let mut buf = Vec::new();
+        serdes::ExpSerde::serialize_into(&commitment, &mut buf).expect("commitment serialization");
+        buf
+    }
+
     fn verify(vs: &Self::VerifierSetup, cg: &ComputationGraph<ECCConfig>, proof: &Self::Proof) -> bool {
         use crate::zkcuda::proving_system::expander::verify_impl::verify_pcs_opening_and_aggregation_no_mpi;
         // Parallel template verification — each template is independent

expander_compiler/src/zkcuda/proving_system/expander_no_oversubscribe/api_no_oversubscribe.rs

@@ -69,6 +69,13 @@ where
         }
     }
 
+    fn commit_single(
+        _prover_setup: &Self::ProverSetup,
+        _device_memory: &[SIMDField<ZC::ECCConfig>],
+    ) -> Vec<u8> {
+        unimplemented!("commit_single not supported for ExpanderNoOverSubscribe")
+    }
+
     fn post_process() {
         wait_async(ClientHttpHelper::request_exit())
     }

expander_compiler/src/zkcuda/proving_system/expander_parallelized/api_parallel.rs

@@ -81,6 +81,13 @@ impl<C: GKREngine, ECCConfig: Config<FieldConfig = C::FieldConfig>> ProvingSyste
         verified.iter().all(|x| *x)
     }
 
+    fn commit_single(
+        _prover_setup: &Self::ProverSetup,
+        _device_memory: &[SIMDField<ECCConfig>],
+    ) -> Vec<u8> {
+        unimplemented!("commit_single not supported for ParallelizedExpander")
+    }
+
     fn post_process() {
         wait_async(ClientHttpHelper::request_exit())
     }

expander_compiler/src/zkcuda/proving_system/expander_pcs_defered/api_pcs_defered.rs

@@ -59,6 +59,13 @@ where
         super::verify_impl::verify(verifier_setup, computation_graph, proof.clone())
     }
 
+    fn commit_single(
+        _prover_setup: &Self::ProverSetup,
+        _device_memory: &[SIMDField<ECCConfig>],
+    ) -> Vec<u8> {
+        unimplemented!("commit_single not supported for ExpanderPCSDefered")
+    }
+
     fn post_process() {
         wait_async(ClientHttpHelper::request_exit())
     }

expander_compiler/src/zkcuda/proving_system/traits.rs

@@ -79,6 +79,14 @@ pub trait ProvingSystem<C: Config> {
         proof: &Self::Proof,
     ) -> bool;
 
+    /// Commit a single device memory and return the serialized commitment bytes.
+    /// Used for deriving challenges from Round 1 commitments in two-round protocols.
+    /// Default implementation is not provided — each backend must implement this.
+    fn commit_single(
+        prover_setup: &Self::ProverSetup,
+        device_memory: &[SIMDField<C>],
+    ) -> Vec<u8>;
+
     /// This is a dedicated function to stop the running service
     /// For most proving systems, this is a no-op
     fn post_process() {}