chore: fix typos and links (#1730)

addressing typos and links to prevent future PRs

---------

Co-authored-by: Copilot <[email protected]>

Author: jonathanpwang

audits/v1-internal/circuit-primitives.md

@@ -535,7 +535,7 @@ Two cases to consider:
 
 The SubAir doesn't explicitly enforce that only the first differing index has a non-zero `diff_inv_marker` value, or that it contains the exact inverse. It only requires that the weighted sum of differences equals 1 when arrays differ. However, the trace generation sets these values correctly for efficiency.
 
-#### 3.2.6 [is_less_than](https://github.com/openvm-org/openvm/blob/main/crates/circuits/primitives/is_less_than.rs)
+#### 3.2.6 [is_less_than](https://github.com/openvm-org/openvm/blob/main/crates/circuits/primitives/src/is_less_than)
 Less than comparison for outputting a boolean indicating `x` < `y`
 
 **Assumptions:**

audits/v1-internal/native-compiler.md

@@ -14,11 +14,11 @@ Commit: 336f1a475e5aa3513c4c5a266399f4128c119bba
 **Severity:** Medium
 **Context:** https://github.com/openvm-org/openvm/blob/336f1a475e5aa3513c4c5a266399f4128c119bba/extensions/native/compiler/src/asm/compiler.rs#L598
 
-**Description:** When allocating memory, `HEAP_PTR` and `A0` could overflow as a field element. This could lead 
-an exploit when the size of memory allocation is based on inputs. 
+**Description:** When allocating memory, `HEAP_PTR` and `A0` could overflow as a field element. This could lead
+an exploit when the size of memory allocation is based on inputs.
 
-The exploit could change `HEAP_PTR` to an arbitrary address, which could point to a loop variable or an 
-end condition. The the exploit could write an arbitrary value into the address and takes control of the 
+The exploit could change `HEAP_PTR` to an arbitrary address, which could point to a loop variable or an
+end condition. The the exploit could write an arbitrary value into the address and takes control of the
 control flow.
 
 **Proof of concept:** N/A
@@ -38,8 +38,8 @@ save columns, `RANGE_CHECK` is put into the existing `JalChip`.
 **Severity:** High
 **Context:** https://github.com/openvm-org/openvm/blob/336f1a475e5aa3513c4c5a266399f4128c119bba/extensions/native/compiler/src/conversion/mod.rs#L274
 
-**Description:** 
-ASM compiler compiles `Assert*` DSL instructions into a conditional jump + a ASM instruction `Trap`, which only results a phantom instruction. The expolit can generate a valid execution trace which ignores all assertions in the program.
+**Description:**
+ASM compiler compiles `Assert*` DSL instructions into a conditional jump + a ASM instruction `Trap`, which only results a phantom instruction. The exploit can generate a valid execution trace which ignores all assertions in the program.
 
 **Proof of concept:** N/A
 
@@ -54,11 +54,11 @@ assertions anymore.
 **Severity:** Medium
 **Context:**: https://github.com/openvm-org/openvm/blob/336f1a475e5aa3513c4c5a266399f4128c119bba/extensions/native/compiler/src/constraints/halo2/compiler.rs#L317
 
-**Description:** 
-The order of `Bn254Fr` is less than `2^254`. A number of 254 bits could overflow. Therefore the bit decomposition 
+**Description:**
+The order of `Bn254Fr` is less than `2^254`. A number of 254 bits could overflow. Therefore the bit decomposition
 of a specific `Bn254Fr` doesn't guarantee an unique representation.
 
-**Recommendation:** 
+**Recommendation:**
 Constraints the bit representation is not in `[p, 2^254)` where `p` is the order of `Bn254Fr`.
 
 **Resolution:** https://github.com/openvm-org/openvm/commit/bff6d573ce7e5304fed5a9e40df9a76647be42ea
@@ -67,15 +67,15 @@ Constraints the bit representation is not in `[p, 2^254)` where `p` is the order
 **Severity:** Low
 **Context:**: https://github.com/openvm-org/openvm/blob/336f1a475e5aa3513c4c5a266399f4128c119bba/extensions/native/compiler/src/asm/compiler.rs#L40
 
-**Description:** 
+**Description:**
 In compiled programs, frame pointers could be negative, which means stackoverflow. Usually compilers support
 recursion so they cannot check stackoverflow at compile time. But ASM compiler can determine all frame pointers
 at compile time so it has the ability to check.
 
 This exploit can happen only when users create lots of stack variables and never access stack variables in
 out of bound addresses(>=`2^29`). So it's very unlikely unless users are malicious.
 
-**Recommendation:** 
+**Recommendation:**
 Assert frame pointers cannot be negative.
 
 **Resolution:** https://github.com/openvm-org/openvm/pull/1416
@@ -98,7 +98,7 @@ Most DSL instructions are trivially converted into the corresponding ASM instruc
 Notably, immediate `Ext` DSL instructions result 5 ASM instruction - the compiler needs to write the immediate `Ext` as 4 `Felt`s first.
 
 ### 3.2 Analysis of Halo2 Compiler
-The Halo2 compiler in `src/asm` converts DSL instructions into Halo2 circuit constraints. The Halo2 compiler 
+The Halo2 compiler in `src/asm` converts DSL instructions into Halo2 circuit constraints. The Halo2 compiler
 doesn't support jump and heap allocation. So it's simpler than the ASM compiler. Almost all DSL instructions
 are simply converted into the corresponding Halo2 circuit constraints.
 

audits/v1-internal/poseidon2-air.md

@@ -6,7 +6,7 @@ Author: https://github.com/MonkeyKing-1
 
 Scope: Plonky3 poseidon2 and poseidon2 air
 
-Understanding how the Plonky3 posiedon2 air works, make sure it is sound.
+Understanding how the Plonky3 poseidon2 air works, make sure it is sound.
 
 ## 2. Findings
 
@@ -40,7 +40,7 @@ The external linear layer takes the current state and does some case work based
 
 - Length 2: compute sum of elements of state and add to each element of state.
 - Length 3: compute sum of elements of state and add to each element of state.
-- Length is multiple of 4: Multiply every four elements by M, giving a new state. Compute the sum of elements with indices that are 0 mod 4, 1 mod 4, etc, computing four sums. Then add these sums to the elements that contributed to them. In other words, perform this multiplication:  
+- Length is multiple of 4: Multiply every four elements by M, giving a new state. Compute the sum of elements with indices that are 0 mod 4, 1 mod 4, etc, computing four sums. Then add these sums to the elements that contributed to them. In other words, perform this multiplication:
   `[[2M M  ... M], [M  2M ... M], ..., [M  M ... 2M]]`.
 
 ### Internal Linear Layer

crates/sdk/tests/integration_test.rs

@@ -64,7 +64,7 @@ const LEAF_LOG_BLOWUP: usize = 2;
 const INTERNAL_LOG_BLOWUP: usize = 3;
 const ROOT_LOG_BLOWUP: usize = 4;
 
-/// `OpenVmHalo2Verifier` wraps the `snark-verifer` contract, meaning that
+/// `OpenVmHalo2Verifier` wraps the `snark-verifier` contract, meaning that
 /// the default `fallback` interface can still be used. This function uses
 /// the fallback interface as opposed to the `verify(..)` interface.
 fn verify_evm_halo2_proof_with_fallback(

extensions/ecc/guest/src/weierstrass.rs

@@ -19,7 +19,7 @@ pub trait WeierstrassPoint: Clone + Sized {
     /// coordinates are in little endian.
     ///
     /// **Warning**: The memory layout of `Self` is expected to pack
-    /// `x` and `y` contigously with no unallocated space in between.
+    /// `x` and `y` contiguously with no unallocated space in between.
     fn as_le_bytes(&self) -> &[u8];
 
     /// Raw constructor without asserting point is on the curve.

extensions/keccak256/circuit/README.md

@@ -4,7 +4,7 @@
 
 The `keccak-air` from Plonky3 is an AIR that does one `keccak-f[1600]` permutation every `NUM_ROUNDS = 24` rows (henceforth we call this the `keccak-f` AIR to avoid confusion). All rows in the round have the same `preimage`, which is the starting state prior to the permutation, represented as `5 * 5 * 4` `u16` limbs (the state in the spec is `5 * 5` `u64`s, but since the AIR uses a 31-bit field, the `u64` is broken into `u16`s).
 
-The `keccak-f` permutation copies `preimage` to `A` and mutates `A` over rounds. The mutations are materialized in the `keccak-f` AIR in `A'` and `A''` arrays. While the bits of `A'` are materialized, the bits of `preimage` and `A` are never materialized (there is an implicit bit compostion in the constraints).
+The `keccak-f` permutation copies `preimage` to `A` and mutates `A` over rounds. The mutations are materialized in the `keccak-f` AIR in `A'` and `A''` arrays. While the bits of `A'` are materialized, the bits of `preimage` and `A` are never materialized (there is an implicit bit composition in the constraints).
 
 ## Review of `keccak256` sponge
 

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

@@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use super::{Array, Config, Ext, Felt, MemIndex, Ptr, RVar, TracedVec, Usize, Var};
 
-/// An intermeddiate instruction set for implementing programs.
+/// An intermediate instruction set for implementing programs.
 ///
 /// Programs written in the DSL can compile both to the recursive zkVM and the R1CS or Plonk-ish
 /// circuits.

extensions/native/recursion/src/fri/two_adic_pcs.rs

@@ -172,7 +172,7 @@ pub fn verify_two_adic_pcs<C: Config>(
         let index_bits = challenger.sample_bits(builder, log_max_lde_height);
 
         // We reset the reduced opening accumulator at the start of each query.
-        // We describe what `ro[log_height]` computes per query in pseduo-code, where `log_height`
+        // We describe what `ro[log_height]` computes per query in pseudo-code, where `log_height`
         // is log2 of the size of the LDE domain: ro[log_height] = 0
         // alpha_pow[log_height] = 1
         // for round in rounds:

extensions/pairing/guest/src/halo2curves_shims/bls12_381/final_exp.rs

@@ -68,7 +68,7 @@ impl FinalExp for Bls12_381 {
 
         root = f.exp_bytes(true, &exp.to_bytes_be());
         let three_be = three.to_bytes_be();
-        // NOTE[yj]: we can probably remove this first check as an optimization since we initizlize
+        // NOTE[yj]: we can probably remove this first check as an optimization since we initialize
         // order_3rd_power to 0
         if root == Fq12::ONE {
             order_3rd_power = 0;

extensions/pairing/guest/src/pairing/final_exp.rs

@@ -9,7 +9,7 @@ pub trait FinalExp {
     type Fp12: Field + FieldExtension<Self::Fp2>;
 
     /// Assert in circuit that the final exponentiation is equal to one. The actual final
-    /// exponentiaton is calculated out of circuit via final_exp_hint. Scalar coefficients
+    /// exponentiation is calculated out of circuit via final_exp_hint. Scalar coefficients
     /// to the curve points must equal to zero, which is checked in a debug_assert.
     fn assert_final_exp_is_one(
         f: &Self::Fp12,