fmt

Author: kunxian-xia

crates/vm/src/metrics/cycle_tracker/mod.rs

@@ -23,12 +23,13 @@ impl CycleTracker {
     pub fn top(&self) -> Option<&String> {
         match self.stack.last() {
             Some(span) => Some(&span.tag),
-            _ => None
+            _ => None,
         }
     }
 
     /// Starts a new cycle tracker span for the given name.
-    /// If a span already exists for the given name, it ends the existing span and pushes a new one to the vec.
+    /// If a span already exists for the given name, it ends the existing span and pushes a new one
+    /// to the vec.
     pub fn start(&mut self, mut name: String, cycles_count: usize) {
         // hack to remove "CT-" prefix
         if name.starts_with("CT-") {

extensions/native/circuit/src/poseidon2/tests.rs

@@ -467,7 +467,7 @@ fn tester_with_random_poseidon2_ops(num_ops: usize) -> VmChipTester<BabyBearBlak
             PERM_POS2 => {
                 tester.write(e, lhs, data_left);
                 tester.write(e, lhs + CHUNK, data_right);
-            },
+            }
             MULTI_OBSERVE => {}
         }
 

extensions/native/compiler/src/asm/compiler.rs

@@ -491,10 +491,15 @@ impl<F: PrimeField32 + TwoAdicField, EF: ExtensionField<F> + TwoAdicField> AsmCo
                 }
                 DslIr::Poseidon2MultiObserve(dst, init_pos, arr_ptr, len) => {
                     self.push(
-            AsmInstruction::Poseidon2MultiObserve(dst.fp(), init_pos.fp(), arr_ptr.fp(), len.get_var().fp()),
+                        AsmInstruction::Poseidon2MultiObserve(
+                            dst.fp(),
+                            init_pos.fp(),
+                            arr_ptr.fp(),
+                            len.get_var().fp(),
+                        ),
                         debug_info,
                     );
-                },
+                }
                 DslIr::Poseidon2PermuteBabyBear(dst, src) => match (dst, src) {
                     (Array::Dyn(dst, _), Array::Dyn(src, _)) => self.push(
                         AsmInstruction::Poseidon2Permute(dst.fp(), src.fp()),

extensions/native/compiler/src/asm/instruction.rs

@@ -340,7 +340,11 @@ impl<F: PrimeField32, EF: ExtensionField<F>> AsmInstruction<F, EF> {
             AsmInstruction::Halt => write!(f, "halt"),
             AsmInstruction::HintBits(src, len) => write!(f, "hint_bits ({})fp, {}", src, len),
             AsmInstruction::Poseidon2MultiObserve(dst, init_pos, arr, len) => {
-                write!(f, "poseidon2_multi_observe ({})fp, ({})fp ({})fp ({})fp", dst, init_pos, arr, len)
+                write!(
+                    f,
+                    "poseidon2_multi_observe ({})fp, ({})fp ({})fp ({})fp",
+                    dst, init_pos, arr, len
+                )
             }
             AsmInstruction::Poseidon2Permute(dst, lhs) => {
                 write!(f, "poseidon2_permute ({})fp, ({})fp", dst, lhs)

extensions/native/compiler/src/ir/instructions.rs

@@ -208,12 +208,13 @@ pub enum DslIr<C: Config> {
     /// Permutes an array of Bn254 elements using Poseidon2 (output = p2_permute(array)). Should
     /// only be used when target is a circuit.
     CircuitPoseidon2Permute([Var<C::N>; 3]),
-    /// Absorbs an array of baby bear elements into a duplex transcript with Poseidon2 permutations (output = p2_multi_observe(array, els)).
+    /// Absorbs an array of baby bear elements into a duplex transcript with Poseidon2 permutations
+    /// (output = p2_multi_observe(array, els)).
     Poseidon2MultiObserve(
-        Ptr<C::N>,              // sponge_state
-        Var<C::N>,              // initial input_ptr position
-        Ptr<C::N>,              // input array (base elements)
-        Usize<C::N>,            // len of els
+        Ptr<C::N>,   // sponge_state
+        Var<C::N>,   // initial input_ptr position
+        Ptr<C::N>,   // input array (base elements)
+        Usize<C::N>, // len of els
     ),
 
     // Miscellaneous instructions.

extensions/native/compiler/src/ir/poseidon.rs

@@ -1,23 +1,22 @@
 use openvm_native_compiler_derive::iter_zip;
 use openvm_stark_backend::p3_field::FieldAlgebra;
 
-use crate::ir::Variable;
-
 use super::{Array, ArrayLike, Builder, Config, DslIr, Ext, Felt, MemIndex, Ptr, Usize, Var};
+use crate::ir::Variable;
 
 pub const DIGEST_SIZE: usize = 8;
 pub const HASH_RATE: usize = 8;
 pub const PERMUTATION_WIDTH: usize = 16;
 
 impl<C: Config> Builder<C> {
     /// Extends native VM ability to observe multiple base elements in one opcode operation
-    /// Absorbs elements sequentially at the RATE portion of sponge state and performs as many permutations as necessary.
-    /// Returns the index position of the next input_ptr.
-    /// 
+    /// Absorbs elements sequentially at the RATE portion of sponge state and performs as many
+    /// permutations as necessary. Returns the index position of the next input_ptr.
+    ///
     /// [Reference](https://docs.rs/p3-poseidon2/latest/p3_poseidon2/struct.Poseidon2.html)
     pub fn poseidon2_multi_observe(
         &mut self,
-        sponge_state: &Array<C, Felt<C::F>>, 
+        sponge_state: &Array<C, Felt<C::F>>,
         input_ptr: Ptr<C::N>,
         arr: &Array<C, Felt<C::F>>,
     ) -> Usize<C::N> {
@@ -28,26 +27,24 @@ impl<C: Config> Builder<C> {
             Array::Fixed(_) => {
                 panic!("Poseidon2 permutation is not allowed on fixed arrays");
             }
-            Array::Dyn(sponge_ptr, _) => {
-                match arr {
-                    Array::Fixed(_) => {
-                        panic!("Base elements input must be dynamic");
-                    }
-                    Array::Dyn(ptr, len) => {
-                        let init_pos: Var<C::N> = Var::uninit(self);
-                        self.assign(&init_pos, input_ptr.address - sponge_ptr.address);
-
-                        self.operations.push(DslIr::Poseidon2MultiObserve(
-                            *sponge_ptr,
-                            init_pos,
-                            *ptr,
-                            len.clone(),
-                        ));
-
-                        Usize::Var(init_pos)
-                    }
+            Array::Dyn(sponge_ptr, _) => match arr {
+                Array::Fixed(_) => {
+                    panic!("Base elements input must be dynamic");
                 }
-            }
+                Array::Dyn(ptr, len) => {
+                    let init_pos: Var<C::N> = Var::uninit(self);
+                    self.assign(&init_pos, input_ptr.address - sponge_ptr.address);
+
+                    self.operations.push(DslIr::Poseidon2MultiObserve(
+                        *sponge_ptr,
+                        init_pos,
+                        *ptr,
+                        len.clone(),
+                    ));
+
+                    Usize::Var(init_pos)
+                }
+            },
         }
     }