M plonky2_verifier/challenger.go → plonky2_verifier/challenger.go

@@ -12,12 +12,6 @@ input_buffer: []V
 	output_buffer: []V
 }
 
-// pub struct Challenger {
-//     sponge_state: [GoldilocksField; SPONGE_WIDTH],
-//     input_buffer: Vec<GoldilocksField>,
-//     output_buffer: Vec<GoldilocksField>
-// }
-
 func NewChallenger() Challenger {
 	var sponge_state [SPONGE_WIDTH]V
 	for i := 0; i < SPONGE_WIDTH; i++ {
@@ -29,31 +23,16 @@ input_buffer: []V{},
 		output_buffer: []V{},
 	}
 }
-//     pub fn new() -> Challenger {
-//         return Challenger {
-//             sponge_state: [GoldilocksField::ZERO; SPONGE_WIDTH],
-//             input_buffer: Vec::with_capacity(SPONGE_RATE),
-//             output_buffer: Vec::with_capacity(SPONGE_RATE)
-//         };
-//     }
 
 func (c *Challenger) observe_elements(elements []V) {
 	for _, element := range elements {
 		c.observe_element(element)
 	}
 }
-//     pub fn observe_elements(&mut self, elements: &[GoldilocksField]) {
-//         for &element in elements {
-//             self.observe_element(element);
-//         }
-//     }
 
 func (c *Challenger) observe_hash(hash []V) {
 	c.observe_elements(hash)
 }
-//     pub fn observe_hash(&mut self, hash: Vec<GoldilocksField>) {
-//         self.observe_elements(&hash.to_vec())
-//     }
 
 func (c *Challenger) observe_element(element V) {
 	c.output_buffer = V[]{}
@@ -62,24 +41,12 @@ if len(c.input_buffer) == SPONGE_RATE {
 		c.duplexing()
 	}
 }
-//     pub fn observe_element(&mut self, element: GoldilocksField) {
-//         self.output_buffer.clear();
-//         self.input_buffer.push(element);
-//         if self.input_buffer.len() == SPONGE_RATE {
-//             self.duplexing();
-//         }
-//     }
 
 func (c *Challenger) observe_cap(cap [][]V) {
 	for _, hash := range cap {
 		c.observe_hash(hash)
 	}
 }
-//     pub fn observe_cap(&mut self, cap: &Vec<Vec<GoldilocksField>>) {
-//         for hash in cap.into_iter() {
-//             self.observe_hash(hash.clone());
-//         }
-//     }
 
 func (c *Challenger) duplexing() {
 	if len(c.input_buffer) > SPONGE_RATE { panic("buffer too large") }
@@ -93,19 +60,6 @@ c.sponge_state = poseidon(c.sponge_state)
 
 	c.output_buffer = c.sponge_state[:SPONGE_RATE]
 }
-//     fn duplexing(&mut self) {
-//         assert!(self.input_buffer.len() <= SPONGE_RATE);
-
-//         for (i, input) in self.input_buffer.drain(..).enumerate() {
-//             self.sponge_state[i] = input;
-//         }
-
-//         self.sponge_state = poseidon(self.sponge_state);
-
-//         self.output_buffer.clear();
-//         self.output_buffer
-//             .extend_from_slice(&self.sponge_state[0..SPONGE_RATE]);
-//     }
 
 func (c *Challenger) get_challenge() V {
 	if len(c.input_buffer) > 0 || len(c.output_buffer) == 0 {
@@ -115,15 +69,6 @@ result := c.output_buffer[len(c.output_buffer) - 1]
 	c.output_buffer = c.output_buffer[:len(c.output_buffer) - 1]
 	return result
 }
-//     pub fn get_challenge(&mut self) -> GoldilocksField {
-//         if !self.input_buffer.is_empty() || self.output_buffer.is_empty() {
-//             self.duplexing();
-//         }
-
-//         self.output_buffer
-//             .pop()
-//             .expect("Output buffer should be non-empty")
-//     }
 
 func (c *Challenger) get_n_challenges(n int) []V {
 	result := make([]V, n)
@@ -132,8 +77,3 @@ result[i] = c.get_challenge()
 	}
 	return result
 }
-//     pub fn get_n_challenges(&mut self, n: usize) -> Vec<GoldilocksField> {
-//         (0..n).map(|_| self.get_challenge()).collect()
-//     }
-// }
-