refactor: replace custom symbolic types with upstream SymbolicAirBuilder

Replace ace-codegen's custom RecordingAirBuilder and SymExpr/SymVar types
with plonky3's upstream SymbolicAirBuilder and SymbolicExpression types.
This aligns constraint capture with the canonical representation and
removes ~430 lines of duplicated symbolic algebra. Also updates
miden-crypto imports for the reorganized module layout (AirBuilder trait
changes, hasher/symmetric paths, prover/verifier submodules).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: adr1anh

Cargo.lock

@@ -64,7 +64,7 @@ miden-utils-testing = { path = "./crates/test-utils", package = "miden-test-util
 miden-verifier = { path = "./verifier", version = "0.22", default-features = false }
 
 # Miden crates
-miden-crypto = { version = "0.23", default-features = false, git = "https://github.com/0xMiden/crypto", branch = "tracking-migration-work" }
+miden-crypto = { version = "0.23", default-features = false, git = "https://github.com/0xMiden/crypto.git", rev = "450a7bd116d24617526c1336000164f29d476ca0" }
 miden-formatting = { version = "0.1", default-features = false }
 midenc-hir-type = { version = "0.4", default-features = false }
 

Cargo.toml

@@ -6,40 +6,42 @@
 use alloc::vec;
 
 use miden_core::field::QuadFelt;
-use miden_crypto::stark::{
-    GenericStarkConfig,
-    challenger::{HashChallenger, SerializingChallenger64},
-    crypto::{
-        CompressionFunctionFromHasher, p3_blake3::Blake3, p3_miden_stateful_hasher::ChainingHasher,
+use miden_crypto::{
+    hash::blake::Blake3Hasher,
+    stark::{
+        GenericStarkConfig,
+        challenger::{HashChallenger, SerializingChallenger64},
+        hasher::ChainingHasher,
+        lmcs::LmcsConfig,
+        symmetric::CompressionFunctionFromHasher,
     },
-    lmcs::LmcsConfig,
 };
 
 use super::{Dft, PCS_PARAMS};
 use crate::Felt;
 
 /// Stateful hasher wrapping Blake3 for LMCS leaf hashing
-type Sponge = ChainingHasher<Blake3>;
+type Sponge = ChainingHasher<Blake3Hasher>;
 
 /// Compression function for Merkle tree internal nodes (Blake3, 32-byte digest)
-type Compress = CompressionFunctionFromHasher<Blake3, 2, 32>;
+type Compress = CompressionFunctionFromHasher<Blake3Hasher, 2, 32>;
 
 /// LMCS commitment scheme using Blake3
 type LmcsType = LmcsConfig<Felt, u8, Sponge, Compress, 32, 32>;
 
 /// Challenger for Fiat-Shamir using Blake3
-type Challenger = SerializingChallenger64<Felt, HashChallenger<u8, Blake3, 32>>;
+type Challenger = SerializingChallenger64<Felt, HashChallenger<u8, Blake3Hasher, 32>>;
 
 /// Complete STARK configuration type for Blake3_256.
 pub type Blake3Config = GenericStarkConfig<Felt, QuadFelt, LmcsType, Dft, Challenger>;
 
 /// Creates a Blake3_256-based STARK configuration.
 pub fn create_blake3_256_config() -> Blake3Config {
-    let sponge = Sponge::new(Blake3);
-    let compress = Compress::new(Blake3);
+    let sponge = Sponge::new(Blake3Hasher);
+    let compress = Compress::new(Blake3Hasher);
     let lmcs = LmcsType::new(sponge, compress);
     let dft = Dft::default();
-    let challenger = Challenger::from_hasher(vec![], Blake3);
+    let challenger = Challenger::from_hasher(vec![], Blake3Hasher);
 
     GenericStarkConfig::new(PCS_PARAMS, lmcs, dft, challenger)
 }

air/src/config/blake3.rs

@@ -3,14 +3,15 @@
 use alloc::vec;
 
 use miden_core::field::QuadFelt;
-use miden_crypto::stark::{
-    GenericStarkConfig,
-    challenger::{HashChallenger, SerializingChallenger64},
-    crypto::{
-        CompressionFunctionFromHasher, p3_keccak::Keccak256Hash,
-        p3_miden_stateful_hasher::ChainingHasher,
+use miden_crypto::{
+    hash::keccak::Keccak256Hash,
+    stark::{
+        GenericStarkConfig,
+        challenger::{HashChallenger, SerializingChallenger64},
+        hasher::ChainingHasher,
+        lmcs::LmcsConfig,
+        symmetric::CompressionFunctionFromHasher,
     },
-    lmcs::LmcsConfig,
 };
 
 use super::{Dft, PCS_PARAMS};

air/src/config/keccak.rs

@@ -12,12 +12,12 @@ use alloc::vec::Vec;
 
 use miden_core::{Felt, field::QuadFelt, utils::RowMajorMatrix};
 use miden_crypto::stark::{
-    AirInstance, StarkConfig, TranscriptData,
-    air::{AuxBuilder, VarLenPublicInputs},
+    StarkConfig,
+    air::{AirInstance, AuxBuilder, VarLenPublicInputs},
     challenger::CanObserve,
     fri::{DeepParams, FriFold, FriParams, PcsParams},
     lmcs::Lmcs,
-    transcript::{ProverTranscript, VerifierTranscript},
+    transcript::{ProverTranscript, TranscriptData, VerifierTranscript},
 };
 use serde::{Serialize, de::DeserializeOwned};
 
@@ -67,7 +67,7 @@ pub const PCS_PARAMS: PcsParams = PcsParams {
 #[derive(Debug, thiserror::Error)]
 pub enum ProvingError {
     #[error(transparent)]
-    Prover(#[from] miden_crypto::stark::ProverError),
+    Prover(#[from] miden_crypto::stark::prover::ProverError),
     #[error("failed to serialize proof: {0}")]
     Serialization(#[from] bincode::Error),
 }
@@ -78,7 +78,7 @@ pub enum VerificationError {
     #[error("failed to deserialize proof: {0}")]
     Deserialization(#[from] bincode::Error),
     #[error(transparent)]
-    Verifier(#[from] miden_crypto::stark::VerifierError),
+    Verifier(#[from] miden_crypto::stark::verifier::VerifierError),
 }
 
 // PROVE / VERIFY
@@ -109,7 +109,7 @@ where
     //   variable-length public inputs.
     // TODO: observe ACE commitment once ACE verification is integrated.
     let mut channel = ProverTranscript::new(challenger);
-    miden_crypto::stark::prove_single(
+    miden_crypto::stark::prover::prove_single(
         config,
         air,
         trace,
@@ -152,6 +152,6 @@ where
         public_values,
         var_len_public_inputs,
     };
-    miden_crypto::stark::verify_multi(config, &[(air, instance)], &mut channel)?;
+    miden_crypto::stark::verifier::verify_multi(config, &[(air, instance)], &mut channel)?;
     Ok(())
 }

air/src/config/mod.rs

@@ -2,13 +2,11 @@
 
 use miden_core::field::QuadFelt;
 use miden_crypto::{
+    field::Field,
     hash::poseidon2::Poseidon2Permutation256,
     stark::{
-        GenericStarkConfig,
-        challenger::DuplexChallenger,
-        crypto::{StatefulSponge, TruncatedPermutation},
-        field::Field,
-        lmcs::LmcsConfig,
+        GenericStarkConfig, challenger::DuplexChallenger, hasher::StatefulSponge, lmcs::LmcsConfig,
+        symmetric::TruncatedPermutation,
     },
 };
 

air/src/config/poseidon2.rs

@@ -2,13 +2,11 @@
 
 use miden_core::field::QuadFelt;
 use miden_crypto::{
+    field::Field,
     hash::rpo::RpoPermutation256,
     stark::{
-        GenericStarkConfig,
-        challenger::DuplexChallenger,
-        crypto::{StatefulSponge, TruncatedPermutation},
-        field::Field,
-        lmcs::LmcsConfig,
+        GenericStarkConfig, challenger::DuplexChallenger, hasher::StatefulSponge, lmcs::LmcsConfig,
+        symmetric::TruncatedPermutation,
     },
 };
 

air/src/config/rpo.rs

@@ -2,13 +2,11 @@
 
 use miden_core::field::QuadFelt;
 use miden_crypto::{
+    field::Field,
     hash::rpx::RpxPermutation256,
     stark::{
-        GenericStarkConfig,
-        challenger::DuplexChallenger,
-        crypto::{StatefulSponge, TruncatedPermutation},
-        field::Field,
-        lmcs::LmcsConfig,
+        GenericStarkConfig, challenger::DuplexChallenger, hasher::StatefulSponge, lmcs::LmcsConfig,
+        symmetric::TruncatedPermutation,
     },
 };
 

air/src/config/rpx.rs

@@ -37,6 +37,7 @@ fn naive_flag(bits: &[Felt; 7], opcode: u8) -> Felt {
     acc
 }
 
+#[allow(clippy::iter_skip_zero)]
 fn naive_op_flags(bits: [Felt; 7]) -> ([Felt; 64], [Felt; 8], [Felt; 16], [Felt; 8]) {
     let mut deg7 = [ZERO; 64];
     let mut deg6 = [ZERO; 8];

air/src/constraints/op_flags/tests.rs

@@ -4,7 +4,7 @@ use alloc::vec::Vec;
 
 use miden_core::{Felt, field::QuadFelt};
 use miden_crypto::stark::{
-    air::{AirBuilder, ExtensionBuilder, PeriodicAirBuilder, PermutationAirBuilder},
+    air::{AirBuilder, EmptyWindow, ExtensionBuilder, PeriodicAirBuilder, PermutationAirBuilder},
     matrix::RowMajorMatrix,
 };
 
@@ -138,18 +138,16 @@ impl AirBuilder for OodEvalAirBuilder {
     type F = Felt;
     type Expr = Felt;
     type Var = Felt;
-    type M = RowMajorMatrix<Felt>;
+    type PreprocessedWindow = EmptyWindow<Felt>;
+    type MainWindow = RowMajorMatrix<Felt>;
     type PublicVar = Felt;
 
-    fn main(&self) -> Self::M {
+    fn main(&self) -> Self::MainWindow {
         self.main.clone()
     }
 
-    fn preprocessed(&self) -> &Self::M {
-        use std::sync::LazyLock;
-        static EMPTY: LazyLock<RowMajorMatrix<Felt>> =
-            LazyLock::new(|| RowMajorMatrix::new(Vec::new(), 0));
-        &EMPTY
+    fn preprocessed(&self) -> &Self::PreprocessedWindow {
+        EmptyWindow::empty_ref()
     }
 
     fn is_first_row(&self) -> Self::Expr {