instruction: add witness generation for poseidon16 instruction

Author: tcoratger

crates/leanVm/src/bytecode/instruction/poseidon16.rs

@@ -5,6 +5,7 @@ use crate::{
     context::run_context::RunContext,
     errors::vm::VirtualMachineError,
     memory::{address::MemoryAddress, manager::MemoryManager},
+    witness::poseidon::WitnessPoseidon16,
 };
 
 /// Poseidon2 permutation over 16 field elements (2 inputs, 2 outputs).
@@ -73,4 +74,44 @@ impl Poseidon2_16Instruction {
 
         Ok(())
     }
+
+    /// Generates the witness for a `Poseidon2_16` instruction execution.
+    pub fn generate_witness(
+        &self,
+        cycle: usize,
+        run_context: &RunContext,
+        memory_manager: &MemoryManager,
+    ) -> Result<WitnessPoseidon16, VirtualMachineError> {
+        // Read the four pointers (input_a, input_b, output_a, output_b) from memory.
+        let base_ptr_addr = (run_context.fp + self.shift)?;
+        let [addr_input_a, addr_input_b, addr_output_a, addr_output_b]: [MemoryAddress; 4] =
+            memory_manager.memory.get_array_as(base_ptr_addr)?;
+
+        // Read the two 8-element input vectors from their respective addresses.
+        let value_a = memory_manager
+            .memory
+            .get_array_as::<F, DIMENSION>(addr_input_a)?;
+        let value_b = memory_manager
+            .memory
+            .get_array_as::<F, DIMENSION>(addr_input_b)?;
+
+        // Read the two 8-element output vectors.
+        let output_a = memory_manager
+            .memory
+            .get_array_as::<F, DIMENSION>(addr_output_a)?;
+        let output_b = memory_manager
+            .memory
+            .get_array_as::<F, DIMENSION>(addr_output_b)?;
+
+        // Construct and return the witness struct.
+        Ok(WitnessPoseidon16 {
+            cycle: Some(cycle),
+            addr_input_a,
+            addr_input_b,
+            // The output address is the start of the first output vector.
+            addr_output: addr_output_a,
+            input: [value_a, value_b].concat().try_into().unwrap(),
+            output: [output_a, output_b].concat().try_into().unwrap(),
+        })
+    }
 }

crates/leanVm/src/witness/poseidon.rs

@@ -1,16 +1,16 @@
-use crate::constant::F;
+use crate::{constant::F, memory::address::MemoryAddress};
 
 /// Holds the high-level witness data for a single Poseidon2 permutation over 16 elements.
 #[derive(Debug)]
 pub struct WitnessPoseidon16 {
     /// The CPU cycle at which this operation is initiated, if applicable.
     pub cycle: Option<usize>,
     /// The memory address (vectorized pointer, of size 1) of the first 8-element input vector.
-    pub addr_input_a: usize,
+    pub addr_input_a: MemoryAddress,
     /// The memory address (vectorized pointer, of size 1) of the second 8-element input vector.
-    pub addr_input_b: usize,
+    pub addr_input_b: MemoryAddress,
     /// The memory address (vectorized pointer, of size 2) where the two 8-element output vectors are stored.
-    pub addr_output: usize,
+    pub addr_output: MemoryAddress,
     /// The full 16-element input state for the permutation.
     pub input: [F; 16],
     /// The full 16-element output state resulting from the permutation.