From 84c5efdaf9772c0a096bd4388b72d797e48ce36d Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Tue, 15 Sep 2026 16:16:24 +0900
Subject: [PATCH 01/14] refactor(stm): share one verifying key codec between
 both circuits

---
 .../src/circuits/halo2/key_serialization.rs   | 32 ++--------
 mithril-stm/src/circuits/halo2/keys.rs        | 25 +-------
 .../circuits/halo2_ivc/key_serialization.rs   | 10 +---
 mithril-stm/src/circuits/key_serialization.rs | 58 +++++++++++++++++++
 mithril-stm/src/circuits/mod.rs               |  1 +
 5 files changed, 68 insertions(+), 58 deletions(-)
 create mode 100644 mithril-stm/src/circuits/key_serialization.rs

diff --git a/mithril-stm/src/circuits/halo2/key_serialization.rs b/mithril-stm/src/circuits/halo2/key_serialization.rs
index aff1857f721..a4da211a870 100644
--- a/mithril-stm/src/circuits/halo2/key_serialization.rs
+++ b/mithril-stm/src/circuits/halo2/key_serialization.rs
@@ -1,37 +1,15 @@
-//! [`TryToBytes`] / [`TryFromBytes`] impls for the certificate circuit's keys — the self-describing
-//! Midnight `MidnightVK` / `MidnightPK` wrappers. Production keys use [`SerdeFormat::RawBytes`].
+//! [`TryToBytes`] / [`TryFromBytes`] impls for the certificate circuit's proving key. Its verifying
+//! key is a `MidnightVK`, whose shared encoding lives in [`crate::circuits::key_serialization`].
 
 use anyhow::Context;
-use midnight_proofs::utils::SerdeFormat;
-use midnight_zk_stdlib::{MidnightPK, MidnightVK};
+use midnight_zk_stdlib::MidnightPK;
 
 use crate::StmResult;
+use crate::circuits::key_serialization::KEY_SERDE_FORMAT;
 use crate::codec::{TryFromBytes, TryToBytes};
 
 use super::circuit::CertificateCircuit;
 
-/// Serde format used for the on-disk / in-cache production keys.
-const KEY_SERDE_FORMAT: SerdeFormat = SerdeFormat::RawBytes;
-
-// Certificate circuit verifying key. `MidnightVK` is self-describing, so reading needs only the
-// serde format (no circuit type), unlike the recursive raw PLONK keys.
-impl TryToBytes for MidnightVK {
-    fn to_bytes_vec(&self) -> StmResult<Vec<u8>> {
-        let mut bytes = Vec::new();
-        self.write(&mut bytes, KEY_SERDE_FORMAT)
-            .with_context(|| "Failed to serialize the certificate verifying key")?;
-        Ok(bytes)
-    }
-}
-
-impl TryFromBytes for MidnightVK {
-    fn try_from_bytes(bytes: &[u8]) -> StmResult<Self> {
-        let mut reader = bytes;
-        MidnightVK::read(&mut reader, KEY_SERDE_FORMAT)
-            .with_context(|| "Failed to deserialize the certificate verifying key")
-    }
-}
-
 // Certificate circuit proving key.
 impl TryToBytes for MidnightPK<CertificateCircuit> {
     fn to_bytes_vec(&self) -> StmResult<Vec<u8>> {
@@ -53,7 +31,7 @@ impl TryFromBytes for MidnightPK<CertificateCircuit> {
 #[cfg(test)]
 mod tests {
     use midnight_proofs::poly::kzg::params::ParamsKZG;
-    use midnight_zk_stdlib::{self as zk, MidnightCircuit};
+    use midnight_zk_stdlib::{self as zk, MidnightCircuit, MidnightVK};
     use rand_chacha::ChaCha20Rng;
     use rand_core::SeedableRng;
 
diff --git a/mithril-stm/src/circuits/halo2/keys.rs b/mithril-stm/src/circuits/halo2/keys.rs
index 47deded4313..8726402f0e5 100644
--- a/mithril-stm/src/circuits/halo2/keys.rs
+++ b/mithril-stm/src/circuits/halo2/keys.rs
@@ -11,6 +11,7 @@ use serde::{Deserialize, Serialize};
 use crate::StmResult;
 use crate::circuits::halo2_ivc::{KZGCommitmentScheme, NativeField, PairingEngine, VerifyingKey};
 use crate::circuits::key_generator::KeyGenerator;
+use crate::circuits::key_serialization::midnight_verifying_key_serde;
 use crate::codec::{TryFromBytes, TryToBytes};
 
 use super::circuit::CertificateCircuit;
@@ -51,30 +52,6 @@ impl AsRef<VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>>>
     }
 }
 
-/// Serde for the wrapped Midnight verifying key: delegates to the key's [`TryToBytes`] /
-/// [`TryFromBytes`] impl so the raw-bytes encoding is defined in one place.
-mod midnight_verifying_key_serde {
-    use midnight_zk_stdlib::MidnightVK;
-    use serde::{Deserializer, Serializer};
-
-    use crate::codec::{TryFromBytes, TryToBytes};
-
-    pub(super) fn serialize<S: Serializer>(
-        verifying_key: &MidnightVK,
-        serializer: S,
-    ) -> Result<S::Ok, S::Error> {
-        let bytes = verifying_key.to_bytes_vec().map_err(serde::ser::Error::custom)?;
-        serializer.serialize_bytes(&bytes)
-    }
-
-    pub(super) fn deserialize<'de, D: Deserializer<'de>>(
-        deserializer: D,
-    ) -> Result<MidnightVK, D::Error> {
-        let bytes: Vec<u8> = serde::Deserialize::deserialize(deserializer)?;
-        MidnightVK::try_from_bytes(&bytes).map_err(serde::de::Error::custom)
-    }
-}
-
 impl NonRecursiveCircuitProvingKey {
     /// Borrows the wrapped Midnight proving key, for proof generation.
     pub(crate) fn midnight_pk(&self) -> &MidnightPK<CertificateCircuit> {
diff --git a/mithril-stm/src/circuits/halo2_ivc/key_serialization.rs b/mithril-stm/src/circuits/halo2_ivc/key_serialization.rs
index 510193c4b19..1b75c4a0131 100644
--- a/mithril-stm/src/circuits/halo2_ivc/key_serialization.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/key_serialization.rs
@@ -1,26 +1,22 @@
 //! [`TryToBytes`] / [`TryFromBytes`] impls for the recursive circuit's raw PLONK keys.
 //!
 //! The raw PLONK `read` is generic over the circuit type and takes its `Params`, so these impls
-//! pin [`IvcCircuitData`] and its `()` params. Production keys use [`SerdeFormat::RawBytes`].
+//! pin [`IvcCircuitData`] and its `()` params.
 //!
 //! Note: only the IVC circuit's keys are ever deserialized raw here (the certificate keys
 //! round-trip as the high-level `MidnightVK` / `MidnightPK`), so pinning `IvcCircuitData` is
 //! correct.
 
-use anyhow::Context;
-use midnight_proofs::utils::SerdeFormat;
-
 use crate::StmResult;
+use crate::circuits::key_serialization::KEY_SERDE_FORMAT;
 use crate::codec::{TryFromBytes, TryToBytes};
+use anyhow::Context;
 
 use super::{
     KZGCommitmentScheme, NativeField, PairingEngine, ProvingKey, VerifyingKey,
     circuit::IvcCircuitData,
 };
 
-/// Serde format used for the on-disk / in-cache production keys.
-const KEY_SERDE_FORMAT: SerdeFormat = SerdeFormat::RawBytes;
-
 // Recursive (IVC) circuit verifying key. The raw PLONK `read` is generic over the circuit and
 // takes its `Params`, so it is pinned to `IvcCircuitData` with its `()` params below.
 impl TryToBytes for VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>> {
diff --git a/mithril-stm/src/circuits/key_serialization.rs b/mithril-stm/src/circuits/key_serialization.rs
new file mode 100644
index 00000000000..ebc79bd0f9a
--- /dev/null
+++ b/mithril-stm/src/circuits/key_serialization.rs
@@ -0,0 +1,58 @@
+//! Byte and serde encodings for a Midnight verifying key, shared by every circuit that stores its
+//! key in that format.
+//!
+//! `MidnightVK` is self-describing and belongs to the standard library, so Rust coherence allows
+//! only one implementation of the crate's byte traits for it. It lives here rather than beside one
+//! circuit's keys so that both circuits reach the same encoding.
+
+use anyhow::Context;
+use midnight_proofs::utils::SerdeFormat;
+use midnight_zk_stdlib::MidnightVK;
+
+use crate::StmResult;
+use crate::codec::{TryFromBytes, TryToBytes};
+
+/// Serde format used for the on-disk / in-cache production keys.
+pub(crate) const KEY_SERDE_FORMAT: SerdeFormat = SerdeFormat::RawBytes;
+
+// `MidnightVK` is self-describing, so reading needs only the serde format, no circuit type.
+impl TryToBytes for MidnightVK {
+    fn to_bytes_vec(&self) -> StmResult<Vec<u8>> {
+        let mut bytes = Vec::new();
+        self.write(&mut bytes, KEY_SERDE_FORMAT)
+            .with_context(|| "Failed to serialize the Midnight verifying key")?;
+        Ok(bytes)
+    }
+}
+
+impl TryFromBytes for MidnightVK {
+    fn try_from_bytes(bytes: &[u8]) -> StmResult<Self> {
+        let mut reader = bytes;
+        MidnightVK::read(&mut reader, KEY_SERDE_FORMAT)
+            .with_context(|| "Failed to deserialize the Midnight verifying key")
+    }
+}
+
+/// Serde for a wrapped Midnight verifying key: delegates to the key's [`TryToBytes`] /
+/// [`TryFromBytes`] impl so the raw-bytes encoding is defined in one place.
+pub(crate) mod midnight_verifying_key_serde {
+    use midnight_zk_stdlib::MidnightVK;
+    use serde::{Deserializer, Serializer};
+
+    use crate::codec::{TryFromBytes, TryToBytes};
+
+    pub(crate) fn serialize<S: Serializer>(
+        verifying_key: &MidnightVK,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let bytes = verifying_key.to_bytes_vec().map_err(serde::ser::Error::custom)?;
+        serializer.serialize_bytes(&bytes)
+    }
+
+    pub(crate) fn deserialize<'de, D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<MidnightVK, D::Error> {
+        let bytes: Vec<u8> = serde::Deserialize::deserialize(deserializer)?;
+        MidnightVK::try_from_bytes(&bytes).map_err(serde::de::Error::custom)
+    }
+}
diff --git a/mithril-stm/src/circuits/mod.rs b/mithril-stm/src/circuits/mod.rs
index bbf3726721e..b97ae39deaa 100644
--- a/mithril-stm/src/circuits/mod.rs
+++ b/mithril-stm/src/circuits/mod.rs
@@ -10,6 +10,7 @@ pub mod halo2;
 pub mod halo2_ivc;
 pub(crate) mod key_generator;
 pub(crate) mod key_provider;
+pub(crate) mod key_serialization;
 pub mod trusted_setup;
 mod verification_key_digest;
 

From 05b234295fa8f396f656e6cabbc09a8ff3d0d088 Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Tue, 15 Sep 2026 16:22:52 +0900
Subject: [PATCH 02/14] refactor(stm): separate the IVC circuit from a single
 step's values

---
 mithril-stm/src/circuits/halo2_ivc/circuit.rs | 109 +++++++++++-------
 1 file changed, 68 insertions(+), 41 deletions(-)

diff --git a/mithril-stm/src/circuits/halo2_ivc/circuit.rs b/mithril-stm/src/circuits/halo2_ivc/circuit.rs
index f6550d3dd6a..f7db4fd9829 100644
--- a/mithril-stm/src/circuits/halo2_ivc/circuit.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/circuit.rs
@@ -18,15 +18,68 @@ use super::{
     witness_assignments,
 };
 
+/// The IVC (Incrementally Verifiable Computation) circuit itself, holding the metadata that fixes
+/// its constraint system: the verifier metadata of the certificate circuit it verifies in-circuit,
+/// and its own.
+///
+/// Mirrors `CertificateCircuit`, which likewise carries only what fixes its constraint system and
+/// none of a single execution's values.
+#[derive(Clone, Debug)]
+pub struct IvcCircuit {
+    // Domain and ConstraintSystem associated with certificate circuit VerifyingKey
+    certificate_circuit_domain_and_constraint_system:
+        (EvaluationDomain<NativeField>, ConstraintSystem<NativeField>),
+    // Domain and ConstraintSystem associated with IVC circuit VerifyingKey
+    ivc_circuit_domain_and_constraint_system:
+        (EvaluationDomain<NativeField>, ConstraintSystem<NativeField>),
+}
+
+impl IvcCircuit {
+    /// Takes both circuits' verifier metadata from their verifying keys.
+    fn from_verification_keys(
+        certificate_verification_key: &NonRecursiveCircuitVerifyingKey,
+        ivc_verification_key: &RecursiveCircuitVerifyingKey,
+    ) -> Self {
+        IvcCircuit {
+            certificate_circuit_domain_and_constraint_system: (
+                certificate_verification_key.as_ref().get_domain().clone(),
+                certificate_verification_key.as_ref().cs().clone(),
+            ),
+            ivc_circuit_domain_and_constraint_system: (
+                ivc_verification_key.as_ref().get_domain().clone(),
+                ivc_verification_key.as_ref().cs().clone(),
+            ),
+        }
+    }
+
+    /// Derives its own verifier metadata from the circuit's configuration, for the key generation
+    /// that has no IVC verifying key to read it from yet.
+    fn for_key_generation(certificate_verification_key: &NonRecursiveCircuitVerifyingKey) -> Self {
+        let mut ivc_circuit_constraint_system = ConstraintSystem::default();
+        configure_ivc_circuit(&mut ivc_circuit_constraint_system);
+        let ivc_circuit_domain = EvaluationDomain::new(
+            ivc_circuit_constraint_system.degree() as u32,
+            RECURSIVE_CIRCUIT_DEGREE,
+        );
+
+        IvcCircuit {
+            certificate_circuit_domain_and_constraint_system: (
+                certificate_verification_key.as_ref().get_domain().clone(),
+                certificate_verification_key.as_ref().cs().clone(),
+            ),
+            ivc_circuit_domain_and_constraint_system: (
+                ivc_circuit_domain,
+                ivc_circuit_constraint_system,
+            ),
+        }
+    }
+}
+
 /// Data required to run one step of the IVC (Incrementally Verifiable Computation) circuit.
 ///
 /// Holds the global root-of-trust, the current state, the next certificate witness,
-/// the associated SNARK proofs, the latest accumulator, and the verification-key metadata
-/// for both the certificate circuit and the IVC circuit itself.
-///
-/// Named for its contents rather than the circuit: unlike `CertificateCircuit`, which carries the
-/// parameters fixing its constraint system, this bundles a concrete step's values with the
-/// verifier metadata required during synthesis.
+/// the associated SNARK proofs and the latest accumulator, alongside the circuit those values are
+/// run against.
 #[derive(Clone, Debug)]
 pub struct IvcCircuitData {
     // Persistent values throughout an ivc stream. This is the root of trust for an ivc stream.
@@ -41,12 +94,8 @@ pub struct IvcCircuitData {
     ivc_proof: CircuitValue<Vec<u8>>,
     // Latest Accumulator
     accumulator: CircuitValue<Accumulator<RecursiveEmulation>>,
-    // Domain and ConstraintSystem associated with certificate circuit VerifyingKey
-    certificate_circuit_domain_and_constraint_system:
-        (EvaluationDomain<NativeField>, ConstraintSystem<NativeField>),
-    // Domain and ConstraintSystem associated with IVC circuit VerifyingKey
-    ivc_circuit_domain_and_constraint_system:
-        (EvaluationDomain<NativeField>, ConstraintSystem<NativeField>),
+    // Circuit these values are run against
+    circuit: IvcCircuit,
 }
 
 impl IvcCircuitData {
@@ -126,13 +175,9 @@ impl IvcCircuitData {
             certificate_proof: CircuitValue::known(certificate_proof.into_vec()),
             ivc_proof: CircuitValue::known(ivc_proof.into_vec()),
             accumulator: CircuitValue::known(accumulator),
-            certificate_circuit_domain_and_constraint_system: (
-                certificate_verification_key.as_ref().get_domain().clone(),
-                certificate_verification_key.as_ref().cs().clone(),
-            ),
-            ivc_circuit_domain_and_constraint_system: (
-                ivc_verification_key.as_ref().get_domain().clone(),
-                ivc_verification_key.as_ref().cs().clone(),
+            circuit: IvcCircuit::from_verification_keys(
+                certificate_verification_key,
+                ivc_verification_key,
             ),
         })
     }
@@ -142,12 +187,6 @@ impl IvcCircuitData {
         certificate_verification_key: &NonRecursiveCircuitVerifyingKey,
     ) -> StmResult<Self> {
         Self::validate_column_counts()?;
-        let mut ivc_circuit_constraint_system = ConstraintSystem::default();
-        configure_ivc_circuit(&mut ivc_circuit_constraint_system);
-        let ivc_circuit_domain = EvaluationDomain::new(
-            ivc_circuit_constraint_system.degree() as u32,
-            RECURSIVE_CIRCUIT_DEGREE,
-        );
 
         Ok(IvcCircuitData {
             global: CircuitValue::unknown(),
@@ -156,14 +195,7 @@ impl IvcCircuitData {
             certificate_proof: CircuitValue::unknown(),
             ivc_proof: CircuitValue::unknown(),
             accumulator: CircuitValue::unknown(),
-            certificate_circuit_domain_and_constraint_system: (
-                certificate_verification_key.as_ref().get_domain().clone(),
-                certificate_verification_key.as_ref().cs().clone(),
-            ),
-            ivc_circuit_domain_and_constraint_system: (
-                ivc_circuit_domain,
-                ivc_circuit_constraint_system,
-            ),
+            circuit: IvcCircuit::for_key_generation(certificate_verification_key),
         })
     }
 }
@@ -181,12 +213,7 @@ impl Circuit<NativeField> for IvcCircuitData {
             certificate_proof: CircuitValue::unknown(),
             ivc_proof: CircuitValue::unknown(),
             accumulator: CircuitValue::unknown(),
-            certificate_circuit_domain_and_constraint_system: self
-                .certificate_circuit_domain_and_constraint_system
-                .clone(),
-            ivc_circuit_domain_and_constraint_system: self
-                .ivc_circuit_domain_and_constraint_system
-                .clone(),
+            circuit: self.circuit.clone(),
         }
     }
 
@@ -206,8 +233,8 @@ impl Circuit<NativeField> for IvcCircuitData {
             &builder,
             &mut layouter,
             &self.global,
-            &self.certificate_circuit_domain_and_constraint_system,
-            &self.ivc_circuit_domain_and_constraint_system,
+            &self.circuit.certificate_circuit_domain_and_constraint_system,
+            &self.circuit.ivc_circuit_domain_and_constraint_system,
         )?;
         // Assign previous state
         let state = witness_assignments::assign_state(&builder, &mut layouter, &self.state)?;

From 6578964c54e6d31cacc861ba646309e6d6aa8f76 Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Wed, 16 Sep 2026 10:02:17 +0900
Subject: [PATCH 03/14] refactor(stm): move the IVC circuit onto the Relation
 trait

The IVC circuit now implements Relation and declares its chips through
ZkStdLibArch instead of a hand written configuration, so both circuits share one
configuration mechanism. The logical statement is unchanged.

The standard library registers gates in a different order, which changes the
recursive circuit's identity, so the recursive keys and every asset derived from
them are regenerated.
---
 .../src/circuits/halo2_ivc/bench/helpers.rs   |  29 +-
 mithril-stm/src/circuits/halo2_ivc/circuit.rs | 392 +++++++++---------
 mithril-stm/src/circuits/halo2_ivc/config.rs  | 144 -------
 .../circuits/halo2_ivc/constraint_builder.rs  | 115 ++---
 .../src/circuits/halo2_ivc/embedded_assets.rs |  16 +-
 mithril-stm/src/circuits/halo2_ivc/errors.rs  |  12 -
 .../halo2_ivc/gadgets/schnorr_signature.rs    |  13 +-
 .../circuits/halo2_ivc/key_serialization.rs   |  40 +-
 mithril-stm/src/circuits/halo2_ivc/keys.rs    |  14 +-
 .../circuits/halo2_ivc/midnight_backend.rs    |   7 +-
 mithril-stm/src/circuits/halo2_ivc/mod.rs     |  31 +-
 ...ircuit_verification_key_for_production.bin | Bin 6054 -> 6054 bytes
 .../tests/assets/genesis_step_output.bin      | Bin 13869 -> 13869 bytes
 ...den_recursive_circuit_verification_key.bin | Bin 6054 -> 6054 bytes
 .../tests/assets/recursive_chain_state.bin    | Bin 13827 -> 13827 bytes
 .../recursive_proof_accumulator_bytes.bin     | Bin 10397 -> 10397 bytes
 .../tests/assets/recursive_step_output.bin    | Bin 17469 -> 17469 bytes
 ...ecursive_step_output_accumulator_bytes.bin | Bin 5759 -> 5759 bytes
 .../tests/assets/same_epoch_step_output.bin   | Bin 17469 -> 17469 bytes
 .../tests/assets/verification_context.bin     | Bin 21142 -> 21142 bytes
 .../tests/common/failure_signature.rs         |  16 +-
 .../common/generators/asset_generation.rs     |  54 ++-
 .../tests/common/generators/proofs.rs         |  18 +-
 .../tests/common/generators/setup.rs          |  13 +-
 .../common/generators/verification_key.rs     |   9 +-
 .../halo2_ivc/tests/common/helpers.rs         |  48 ++-
 .../halo2_ivc/tests/encoding/negative.rs      |   2 +
 .../halo2_ivc/tests/encoding/positive.rs      |  17 +-
 .../halo2_ivc/tests/golden/positive.rs        |   1 +
 .../halo2_ivc/tests/in_circuit/accumulator.rs |   9 +-
 .../tests/in_circuit/genesis_gating.rs        |  16 +-
 .../tests/off_circuit/circuit_validation.rs   |   4 +-
 .../tests/transitions/negative/genesis.rs     |   1 +
 .../tests/transitions/negative/next_epoch.rs  |   1 +
 .../tests/transitions/negative/same_epoch.rs  |   1 +
 .../halo2_ivc/tests/transitions/positive.rs   |   2 +
 .../tests/verification_key_computation.rs     |   9 +-
 .../circuits/halo2_ivc/witness_assignments.rs |  16 +-
 mithril-stm/src/circuits/key_provider.rs      |  81 +++-
 .../src/circuits/verification_key_digest.rs   |   4 +-
 .../src/proof_system/halo2_ivc_snark/proof.rs |  43 +-
 .../aggregate_signature/ancillary_data.rs     |   7 +-
 42 files changed, 582 insertions(+), 603 deletions(-)
 delete mode 100644 mithril-stm/src/circuits/halo2_ivc/config.rs

diff --git a/mithril-stm/src/circuits/halo2_ivc/bench/helpers.rs b/mithril-stm/src/circuits/halo2_ivc/bench/helpers.rs
index d762c74f30a..90df7b4428a 100644
--- a/mithril-stm/src/circuits/halo2_ivc/bench/helpers.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/bench/helpers.rs
@@ -37,7 +37,7 @@ use crate::{
         halo2::{circuit::CertificateCircuit, types::CircuitBase},
         halo2_ivc::{
             PREIMAGE_SIZE, RECURSIVE_CIRCUIT_DEGREE,
-            circuit::IvcCircuitData,
+            circuit::{IvcCircuit, IvcCircuitData},
             embedded_assets::{
                 FollowingCertificateInEpochAsset, NextEpochStepOutputAsset,
                 load_embedded_following_certificate_in_epoch_asset,
@@ -82,7 +82,8 @@ pub enum TransitionPath {
 /// Everything one path needs across the measured operations, built untimed and validated once.
 pub struct PreparedStep {
     path: TransitionPath,
-    // Prover inputs: `create_proof` runs over this prebuilt circuit data and public inputs.
+    // Prover inputs: `create_proof` runs over this prebuilt relation, circuit data and public inputs.
+    ivc_circuit: IvcCircuit,
     circuit_data: IvcCircuitData,
     public_inputs: Vec<CircuitBase>,
     // Verifier inputs: the committed step proof and the state/accumulator/message it is checked against.
@@ -262,16 +263,18 @@ impl IvcBenchEnv {
         let prover_input =
             IvcProverInput::prepare_genesis(&rolling_state, &preimage, &self.global)?;
 
-        let circuit_data = IvcCircuitData::try_new(
+        let ivc_circuit = IvcCircuit::try_new(
+            &self.setup.certificate_verifying_key,
+            &self.setup.ivc_verifying_key,
+        )?;
+        let circuit_data = IvcCircuitData::new(
             self.global.clone(),
             rolling_state.state().clone(),
             prover_input.witness,
             CertificateProofBytes::empty(),
             rolling_state.ivc_proof().clone(),
             rolling_state.accumulator().clone(),
-            &self.setup.certificate_verifying_key,
-            &self.setup.ivc_verifying_key,
-        )?;
+        );
         let public_inputs =
             self.public_inputs_for(&prover_input.next_state, &prover_input.next_accumulator);
 
@@ -289,6 +292,7 @@ impl IvcBenchEnv {
 
         Ok(PreparedStep {
             path: TransitionPath::Genesis,
+            ivc_circuit,
             circuit_data,
             public_inputs,
             proof_bytes: genesis_output.ivc_proof,
@@ -336,16 +340,18 @@ impl IvcBenchEnv {
             &self.setup.prover_input_verification_context(),
         )?;
 
-        let circuit_data = IvcCircuitData::try_new(
+        let ivc_circuit = IvcCircuit::try_new(
+            &self.setup.certificate_verifying_key,
+            &self.setup.ivc_verifying_key,
+        )?;
+        let circuit_data = IvcCircuitData::new(
             self.global.clone(),
             rolling_state.state().clone(),
             prover_input.witness,
             asset.certificate_proof,
             rolling_state.ivc_proof().clone(),
             rolling_state.accumulator().clone(),
-            &self.setup.certificate_verifying_key,
-            &self.setup.ivc_verifying_key,
-        )?;
+        );
         let public_inputs =
             self.public_inputs_for(&prover_input.next_state, &prover_input.next_accumulator);
 
@@ -366,6 +372,7 @@ impl IvcBenchEnv {
 
         Ok(PreparedStep {
             path,
+            ivc_circuit,
             circuit_data,
             public_inputs,
             proof_bytes: asset.ivc_proof,
@@ -460,6 +467,7 @@ impl IvcBenchEnv {
         IvcProof::<PoseidonState<CircuitBase>>::prove_with_transcript(
             &self.setup.srs,
             &self.setup.ivc_proving_key,
+            &prepared.ivc_circuit,
             &prepared.circuit_data,
             &prepared.public_inputs,
             &mut OsRng,
@@ -471,6 +479,7 @@ impl IvcBenchEnv {
         IvcProof::<Blake2b256>::prove_with_transcript(
             &self.setup.srs,
             &self.setup.ivc_proving_key,
+            &prepared.ivc_circuit,
             &prepared.circuit_data,
             &prepared.public_inputs,
             &mut OsRng,
diff --git a/mithril-stm/src/circuits/halo2_ivc/circuit.rs b/mithril-stm/src/circuits/halo2_ivc/circuit.rs
index f7db4fd9829..63661ec9fab 100644
--- a/mithril-stm/src/circuits/halo2_ivc/circuit.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/circuit.rs
@@ -4,101 +4,57 @@ use crate::circuits::halo2_ivc::keys::RecursiveCircuitVerifyingKey;
 use anyhow::anyhow;
 
 use super::{
-    Accumulator, BinaryInstructions, Circuit, CircuitValue, ComposableChip, ConstraintSystem,
-    EmulatedCurve, Error, EvaluationDomain, IvcNativeGadget, Layouter, NB_ARITH_COLS,
-    NB_ARITH_FIXED_COLS, NB_EDWARDS_COLS, NB_POSEIDON_ADVICE_COLS, NB_POSEIDON_FIXED_COLS,
-    NB_SHA256_ADVICE_COLS, NB_SHA256_FIXED_COLS, NativeField, PublicInputInstructions,
-    RECURSIVE_CIRCUIT_DEGREE, RecursiveEmulation, SimpleFloorPlanner,
-    config::{IvcConfig, configure_ivc_circuit, ivc_column_pool_sizes},
+    Accumulator, BinaryInstructions, CircuitValue, ConstraintSystem, Error, EvaluationDomain,
+    Layouter, NativeField, PublicInputInstructions, RECURSIVE_CIRCUIT_DEGREE, RecursiveEmulation,
+    Relation, ZkStdLib, ZkStdLibArch,
     constraint_builder::IvcConstraintBuilder,
     errors::IvcCircuitError,
-    nb_foreign_ecc_chip_columns,
     state::{Global, State, Witness},
     types::{CertificateProofBytes, IvcProofBytes},
     witness_assignments,
 };
+use crate::codec::{TryFromBytes, TryToBytes};
 
-/// The IVC (Incrementally Verifiable Computation) circuit itself, holding the metadata that fixes
-/// its constraint system: the verifier metadata of the certificate circuit it verifies in-circuit,
-/// and its own.
+/// Chips the recursive circuit enables.
+///
+/// Single source: the relation declares these to the standard library, and key generation
+/// configures its own verifier metadata from the same value, so the two cannot drift.
+pub(crate) fn recursive_circuit_architecture() -> ZkStdLibArch {
+    ZkStdLibArch {
+        jubjub: true,
+        poseidon: true,
+        sha2_256: true,
+        sha2_512: false,
+        keccak_256: false,
+        sha3_256: false,
+        secp256k1: false,
+        bls12_381: true,
+        base64: false,
+        nr_pow2range_cols: 4,
+        automaton: false,
+        blake2b: false,
+        curve25519: false,
+        p256: false,
+    }
+}
+
+/// The IVC (Incrementally Verifiable Computation) circuit, holding what fixes its constraint
+/// system: the certificate circuit whose proofs it verifies in-circuit, and its own verifier
+/// metadata.
 ///
 /// Mirrors `CertificateCircuit`, which likewise carries only what fixes its constraint system and
 /// none of a single execution's values.
 #[derive(Clone, Debug)]
 pub struct IvcCircuit {
-    // Domain and ConstraintSystem associated with certificate circuit VerifyingKey
-    certificate_circuit_domain_and_constraint_system:
-        (EvaluationDomain<NativeField>, ConstraintSystem<NativeField>),
+    // Certificate circuit verified in-circuit: its domain and constraint system are the verifier
+    // metadata, and it is what a serialized relation carries.
+    certificate_verification_key: NonRecursiveCircuitVerifyingKey,
     // Domain and ConstraintSystem associated with IVC circuit VerifyingKey
     ivc_circuit_domain_and_constraint_system:
         (EvaluationDomain<NativeField>, ConstraintSystem<NativeField>),
 }
 
 impl IvcCircuit {
-    /// Takes both circuits' verifier metadata from their verifying keys.
-    fn from_verification_keys(
-        certificate_verification_key: &NonRecursiveCircuitVerifyingKey,
-        ivc_verification_key: &RecursiveCircuitVerifyingKey,
-    ) -> Self {
-        IvcCircuit {
-            certificate_circuit_domain_and_constraint_system: (
-                certificate_verification_key.as_ref().get_domain().clone(),
-                certificate_verification_key.as_ref().cs().clone(),
-            ),
-            ivc_circuit_domain_and_constraint_system: (
-                ivc_verification_key.as_ref().get_domain().clone(),
-                ivc_verification_key.as_ref().cs().clone(),
-            ),
-        }
-    }
-
-    /// Derives its own verifier metadata from the circuit's configuration, for the key generation
-    /// that has no IVC verifying key to read it from yet.
-    fn for_key_generation(certificate_verification_key: &NonRecursiveCircuitVerifyingKey) -> Self {
-        let mut ivc_circuit_constraint_system = ConstraintSystem::default();
-        configure_ivc_circuit(&mut ivc_circuit_constraint_system);
-        let ivc_circuit_domain = EvaluationDomain::new(
-            ivc_circuit_constraint_system.degree() as u32,
-            RECURSIVE_CIRCUIT_DEGREE,
-        );
-
-        IvcCircuit {
-            certificate_circuit_domain_and_constraint_system: (
-                certificate_verification_key.as_ref().get_domain().clone(),
-                certificate_verification_key.as_ref().cs().clone(),
-            ),
-            ivc_circuit_domain_and_constraint_system: (
-                ivc_circuit_domain,
-                ivc_circuit_constraint_system,
-            ),
-        }
-    }
-}
-
-/// Data required to run one step of the IVC (Incrementally Verifiable Computation) circuit.
-///
-/// Holds the global root-of-trust, the current state, the next certificate witness,
-/// the associated SNARK proofs and the latest accumulator, alongside the circuit those values are
-/// run against.
-#[derive(Clone, Debug)]
-pub struct IvcCircuitData {
-    // Persistent values throughout an ivc stream. This is the root of trust for an ivc stream.
-    global: CircuitValue<Global>,
-    // State values from the last aggregated certificate
-    state: CircuitValue<State>,
-    // Witness (mainly the next certificate to be aggregated) for deriving the next state
-    witness: CircuitValue<Witness>,
-    // Snark proof of the next certificate
-    certificate_proof: CircuitValue<Vec<u8>>,
-    // Latest IVC proof
-    ivc_proof: CircuitValue<Vec<u8>>,
-    // Latest Accumulator
-    accumulator: CircuitValue<Accumulator<RecursiveEmulation>>,
-    // Circuit these values are run against
-    circuit: IvcCircuit,
-}
-
-impl IvcCircuitData {
     /// Validates that the IVC verification key degree matches the IVC circuit degree constant RECURSIVE_CIRCUIT_DEGREE.
     pub(crate) fn validate_ivc_verification_key_degree(
         ivc_verification_key: &RecursiveCircuitVerifyingKey,
@@ -113,144 +69,105 @@ impl IvcCircuitData {
         Ok(())
     }
 
-    /// Validates that the column pool allocated by `configure_ivc_circuit` is large enough
-    /// for every chip. Must be called before `Circuit::configure` is reached (e.g. in
-    /// `try_new` and `unknown`) so that the `.expect` calls inside `configure_ivc_circuit`
-    /// are guaranteed not to trigger.
-    fn validate_column_counts() -> StmResult<()> {
-        let (nb_advice_cols, nb_fixed_cols) = ivc_column_pool_sizes();
-
-        for needed in [
-            NB_ARITH_COLS,
-            NB_EDWARDS_COLS,
-            NB_POSEIDON_ADVICE_COLS,
-            NB_SHA256_ADVICE_COLS,
-            nb_foreign_ecc_chip_columns::<NativeField, EmulatedCurve, EmulatedCurve, IvcNativeGadget>(
-            ),
-        ] {
-            if needed > nb_advice_cols {
-                return Err(anyhow!(IvcCircuitError::InsufficientAdviceColumns {
-                    needed,
-                    available: nb_advice_cols,
-                }));
-            }
-        }
-
-        for needed in [NB_ARITH_FIXED_COLS, NB_POSEIDON_FIXED_COLS, NB_SHA256_FIXED_COLS] {
-            if needed > nb_fixed_cols {
-                return Err(anyhow!(IvcCircuitError::InsufficientFixedColumns {
-                    needed,
-                    available: nb_fixed_cols,
-                }));
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Creates a new `IvcCircuitData` with the given witness and proof data.
-    ///
-    /// Validates that `ivc_verification_key` has degree `RECURSIVE_CIRCUIT_DEGREE` and that the column pool allocated by
-    /// `configure_ivc_circuit` is sufficient for all chips. Returns an error containing
-    /// [`IvcCircuitError::IvcVerificationKeyDegreeMismatch`] or
-    /// [`IvcCircuitError::InsufficientAdviceColumns`] /
-    /// [`IvcCircuitError::InsufficientFixedColumns`] if either check fails.
-    #[allow(clippy::too_many_arguments)]
+    /// Builds the circuit from both circuits' verifying keys.
     pub(crate) fn try_new(
-        global: Global,
-        state: State,
-        witness: Witness,
-        certificate_proof: CertificateProofBytes,
-        ivc_proof: IvcProofBytes,
-        accumulator: Accumulator<RecursiveEmulation>,
         certificate_verification_key: &NonRecursiveCircuitVerifyingKey,
         ivc_verification_key: &RecursiveCircuitVerifyingKey,
     ) -> StmResult<Self> {
         Self::validate_ivc_verification_key_degree(ivc_verification_key)?;
-        Self::validate_column_counts()?;
-        Ok(IvcCircuitData {
-            global: CircuitValue::known(global),
-            state: CircuitValue::known(state),
-            witness: CircuitValue::known(witness),
-            certificate_proof: CircuitValue::known(certificate_proof.into_vec()),
-            ivc_proof: CircuitValue::known(ivc_proof.into_vec()),
-            accumulator: CircuitValue::known(accumulator),
-            circuit: IvcCircuit::from_verification_keys(
-                certificate_verification_key,
-                ivc_verification_key,
+
+        Ok(IvcCircuit {
+            certificate_verification_key: certificate_verification_key.clone(),
+            ivc_circuit_domain_and_constraint_system: (
+                ivc_verification_key.as_ref().get_domain().clone(),
+                ivc_verification_key.as_ref().cs().clone(),
             ),
         })
     }
 
-    /// Creates a default IVC circuit for generating the proving and verifying keys.
-    pub fn unknown(
+    /// Derives its own verifier metadata from the circuit's configuration, for the key generation
+    /// that has no IVC verifying key to read it from yet.
+    pub(crate) fn for_key_generation(
         certificate_verification_key: &NonRecursiveCircuitVerifyingKey,
-    ) -> StmResult<Self> {
-        Self::validate_column_counts()?;
-
-        Ok(IvcCircuitData {
-            global: CircuitValue::unknown(),
-            state: CircuitValue::unknown(),
-            witness: CircuitValue::unknown(),
-            certificate_proof: CircuitValue::unknown(),
-            ivc_proof: CircuitValue::unknown(),
-            accumulator: CircuitValue::unknown(),
-            circuit: IvcCircuit::for_key_generation(certificate_verification_key),
-        })
-    }
-}
-
-impl Circuit<NativeField> for IvcCircuitData {
-    type Config = IvcConfig;
-    type FloorPlanner = SimpleFloorPlanner;
-    type Params = ();
+    ) -> Self {
+        let mut ivc_circuit_constraint_system = ConstraintSystem::default();
+        ZkStdLib::configure(
+            &mut ivc_circuit_constraint_system,
+            (
+                recursive_circuit_architecture(),
+                (RECURSIVE_CIRCUIT_DEGREE - 1) as u8,
+            ),
+        );
+        let ivc_circuit_domain = EvaluationDomain::new(
+            ivc_circuit_constraint_system.degree() as u32,
+            RECURSIVE_CIRCUIT_DEGREE,
+        );
 
-    fn without_witnesses(&self) -> Self {
-        IvcCircuitData {
-            global: CircuitValue::unknown(),
-            state: CircuitValue::unknown(),
-            witness: CircuitValue::unknown(),
-            certificate_proof: CircuitValue::unknown(),
-            ivc_proof: CircuitValue::unknown(),
-            accumulator: CircuitValue::unknown(),
-            circuit: self.circuit.clone(),
+        IvcCircuit {
+            certificate_verification_key: certificate_verification_key.clone(),
+            ivc_circuit_domain_and_constraint_system: (
+                ivc_circuit_domain,
+                ivc_circuit_constraint_system,
+            ),
         }
     }
+}
 
-    fn configure(meta: &mut ConstraintSystem<NativeField>) -> Self::Config {
-        configure_ivc_circuit(meta)
+impl Relation for IvcCircuit {
+    type Error = Error;
+    type Instance = Vec<NativeField>;
+    type Witness = IvcCircuitData;
+
+    fn format_instance(instance: &Self::Instance) -> Result<Vec<NativeField>, Error> {
+        Ok(instance.clone())
     }
 
-    fn synthesize(
+    /// The statement is constrained by the assignment helpers below as each part is derived, so the
+    /// instance argument is not assigned a second time here.
+    fn circuit(
         &self,
-        config: Self::Config,
-        mut layouter: impl Layouter<NativeField>,
+        std_lib: &ZkStdLib,
+        layouter: &mut impl Layouter<NativeField>,
+        _instance: CircuitValue<Self::Instance>,
+        witness: CircuitValue<Self::Witness>,
     ) -> Result<(), Error> {
-        let builder = IvcConstraintBuilder::new(&config);
+        let builder = IvcConstraintBuilder::new(std_lib);
+
+        let global_value = witness.clone().map(|data| data.global);
+        let state_value = witness.clone().map(|data| data.state);
+        let witness_value = witness.clone().map(|data| data.witness);
+        let certificate_proof_value = witness.clone().map(|data| data.certificate_proof);
+        let ivc_proof_value = witness.clone().map(|data| data.ivc_proof);
+        let accumulator_value = witness.map(|data| data.accumulator);
+
+        let (ivc_circuit_domain, ivc_circuit_constraint_system) =
+            &self.ivc_circuit_domain_and_constraint_system;
 
         // Assign global and constraint it as public input
         let global = witness_assignments::assign_global_as_public_input(
             &builder,
-            &mut layouter,
-            &self.global,
-            &self.circuit.certificate_circuit_domain_and_constraint_system,
-            &self.circuit.ivc_circuit_domain_and_constraint_system,
+            layouter,
+            &global_value,
+            self.certificate_verification_key.as_ref().get_domain(),
+            self.certificate_verification_key.as_ref().cs(),
+            ivc_circuit_domain,
+            ivc_circuit_constraint_system,
         )?;
         // Assign previous state
-        let state = witness_assignments::assign_state(&builder, &mut layouter, &self.state)?;
+        let state = witness_assignments::assign_state(&builder, layouter, &state_value)?;
         // Assign witness for the new certificate to be aggregated
-        let witness = witness_assignments::assign_witness(&builder, &mut layouter, &self.witness)?;
+        let witness = witness_assignments::assign_witness(&builder, layouter, &witness_value)?;
 
         // If state.step_counter = 0, we are aggregating the genesis certificate
-        let is_genesis = builder.is_genesis(&mut layouter, &state)?;
-        let is_not_genesis = builder.native_gadget.not(&mut layouter, &is_genesis)?;
+        let is_genesis = builder.is_genesis(layouter, &state)?;
+        let is_not_genesis = builder.native_gadget.not(layouter, &is_genesis)?;
 
         // Verify genesis certificate
-        builder.assert_genesis(&mut layouter, &is_not_genesis, &global, &witness)?;
+        builder.assert_genesis(layouter, &is_not_genesis, &global, &witness)?;
 
         // Verify certificate chain link between the last aggregated certificate and the new certificate to obtain the next state
         let next_state = builder.transition(
-            &mut layouter,
+            layouter,
             &is_genesis,
             &is_not_genesis,
             &global,
@@ -258,26 +175,88 @@ impl Circuit<NativeField> for IvcCircuitData {
             &witness,
         )?;
         // Constrain the next state as public input
-        witness_assignments::constrain_state_as_public_input(&builder, &mut layouter, &next_state)?;
+        witness_assignments::constrain_state_as_public_input(&builder, layouter, &next_state)?;
 
         // Verify (prepare) certificate_proof and previous ivc_proof and update accumulator
         let next_acc = builder.verify_prepare(
-            &mut layouter,
+            layouter,
             &global,
             &is_not_genesis,
             &state,
             &witness,
-            &self.certificate_proof,
-            &self.ivc_proof,
-            &self.accumulator,
+            &certificate_proof_value,
+            &ivc_proof_value,
+            &accumulator_value,
         )?;
         // Constrain the next accumulator as public input
-        builder
-            .verifier_gadget
-            .constrain_as_public_input(&mut layouter, &next_acc)?;
+        builder.verifier_gadget.constrain_as_public_input(layouter, &next_acc)
+    }
 
-        builder.core_decomp_chip.load(&mut layouter)?;
-        builder.sha2_256_chip.load(&mut layouter)
+    fn used_chips(&self) -> ZkStdLibArch {
+        recursive_circuit_architecture()
+    }
+
+    fn write_relation<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        let bytes = self
+            .certificate_verification_key
+            .to_bytes_vec()
+            .map_err(|error| std::io::Error::other(error.to_string()))?;
+        writer.write_all(&(bytes.len() as u32).to_le_bytes())?;
+        writer.write_all(&bytes)
+    }
+
+    fn read_relation<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
+        let mut length_bytes = [0u8; 4];
+        reader.read_exact(&mut length_bytes)?;
+        let mut bytes = vec![0u8; u32::from_le_bytes(length_bytes) as usize];
+        reader.read_exact(&mut bytes)?;
+
+        let certificate_verification_key = NonRecursiveCircuitVerifyingKey::try_from_bytes(&bytes)
+            .map_err(|error| std::io::Error::other(error.to_string()))?;
+
+        Ok(Self::for_key_generation(&certificate_verification_key))
+    }
+}
+
+/// Values of one step of the IVC (Incrementally Verifiable Computation) circuit: the witness of the
+/// relation above.
+///
+/// Holds the global root-of-trust, the current state, the next certificate witness, the associated
+/// SNARK proofs and the latest accumulator.
+#[derive(Clone, Debug)]
+pub struct IvcCircuitData {
+    // Persistent values throughout an ivc stream. This is the root of trust for an ivc stream.
+    global: Global,
+    // State values from the last aggregated certificate
+    state: State,
+    // Witness (mainly the next certificate to be aggregated) for deriving the next state
+    witness: Witness,
+    // Snark proof of the next certificate
+    certificate_proof: Vec<u8>,
+    // Latest IVC proof
+    ivc_proof: Vec<u8>,
+    // Latest Accumulator
+    accumulator: Accumulator<RecursiveEmulation>,
+}
+
+impl IvcCircuitData {
+    /// Collects the values of a single IVC step.
+    pub(crate) fn new(
+        global: Global,
+        state: State,
+        witness: Witness,
+        certificate_proof: CertificateProofBytes,
+        ivc_proof: IvcProofBytes,
+        accumulator: Accumulator<RecursiveEmulation>,
+    ) -> Self {
+        IvcCircuitData {
+            global,
+            state,
+            witness,
+            certificate_proof: certificate_proof.into_vec(),
+            ivc_proof: ivc_proof.into_vec(),
+            accumulator,
+        }
     }
 }
 
@@ -293,12 +272,27 @@ mod tests {
         codec::TryFromBytes,
     };
 
+    use midnight_zk_stdlib::MidnightCircuit;
+
     use super::*;
 
+    fn production_certificate_verification_key() -> NonRecursiveCircuitVerifyingKey {
+        NonRecursiveCircuitVerifyingKey::try_from_bytes(
+            NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
+        )
+        .unwrap()
+    }
+
     #[test]
     fn ivc_circuit_constraint_count() {
         let mut cs = ConstraintSystem::<NativeField>::default();
-        configure_ivc_circuit(&mut cs);
+        ZkStdLib::configure(
+            &mut cs,
+            (
+                recursive_circuit_architecture(),
+                (RECURSIVE_CIRCUIT_DEGREE - 1) as u8,
+            ),
+        );
 
         let poly_constraints: usize = cs.gates().iter().map(|g| g.polynomials().len()).sum();
         assert_eq!(
@@ -318,16 +312,14 @@ mod tests {
 
     #[test]
     fn recursive_circuit_constraint_degree_stays_constant() {
-        let certificate_verification_key = NonRecursiveCircuitVerifyingKey::try_from_bytes(
-            NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
-        )
-        .unwrap();
-        let ivc_data = IvcCircuitData::unknown(&certificate_verification_key).unwrap();
+        let certificate_verification_key = production_certificate_verification_key();
+        let ivc_circuit = IvcCircuit::for_key_generation(&certificate_verification_key);
+        let circuit = MidnightCircuit::from_relation(&ivc_circuit, Some(RECURSIVE_CIRCUIT_DEGREE));
 
         const SIZE_BLS12_KZG_COMMITMENT: usize = 48;
         const SIZE_SCALAR_FIELD_ELEMENT: usize = 32;
         let circuit_model =
-            circuit_model::<_, SIZE_BLS12_KZG_COMMITMENT, SIZE_SCALAR_FIELD_ELEMENT>(&ivc_data);
+            circuit_model::<_, SIZE_BLS12_KZG_COMMITMENT, SIZE_SCALAR_FIELD_ELEMENT>(&circuit);
 
         assert_eq!(circuit_model.k, RECURSIVE_CIRCUIT_DEGREE);
     }
diff --git a/mithril-stm/src/circuits/halo2_ivc/config.rs b/mithril-stm/src/circuits/halo2_ivc/config.rs
deleted file mode 100644
index 1a53ef7f5a3..00000000000
--- a/mithril-stm/src/circuits/halo2_ivc/config.rs
+++ /dev/null
@@ -1,144 +0,0 @@
-use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_DEGREE;
-
-use super::{
-    CircuitCurve, ComposableChip, ConstraintSystem, EccChip, EccConfig, EmulatedCurve,
-    EmulatedCurveBaseField, FieldChip, ForeignWeierstrassEccChip, ForeignWeierstrassEccConfig,
-    IvcNativeGadget, NB_ARITH_COLS, NB_ARITH_FIXED_COLS, NB_EDWARDS_COLS, NB_POSEIDON_ADVICE_COLS,
-    NB_POSEIDON_FIXED_COLS, NativeChip, NativeConfig, NativeField, P2RDecompositionChip,
-    P2RDecompositionConfig, PoseidonChip, PoseidonConfig, Pow2RangeChip,
-    nb_foreign_ecc_chip_columns,
-};
-use midnight_circuits::hash::sha256::{
-    NB_SHA256_ADVICE_COLS, NB_SHA256_FIXED_COLS, Sha256Chip, Sha256Config,
-};
-
-#[derive(Debug, Clone)]
-pub struct IvcConfig {
-    pub(crate) native_config: NativeConfig,
-    pub(crate) core_decomp_config: P2RDecompositionConfig,
-    pub(crate) jubjub_config: EccConfig,
-    pub(crate) bls12_381_config: ForeignWeierstrassEccConfig<EmulatedCurve>,
-    pub(crate) poseidon_config: PoseidonConfig<NativeField>,
-    pub(crate) sha256_config: Sha256Config,
-}
-
-/// Returns `(nb_advice_cols, nb_fixed_cols)` — the column pool sizes allocated by
-/// `configure_ivc_circuit`. Single source of truth shared with `validate_column_counts`.
-pub(crate) fn ivc_column_pool_sizes() -> (usize, usize) {
-    // unwrap_or(0) never panics: max() returns None only on an empty iterator,
-    // but both arrays are non-empty so the fallback is unreachable.
-    let nb_advice_cols = [
-        NB_ARITH_COLS,
-        NB_EDWARDS_COLS,
-        NB_POSEIDON_ADVICE_COLS,
-        NB_SHA256_ADVICE_COLS,
-        nb_foreign_ecc_chip_columns::<NativeField, EmulatedCurve, EmulatedCurve, IvcNativeGadget>(),
-    ]
-    .into_iter()
-    .max()
-    .unwrap_or(0);
-
-    let nb_fixed_cols = [NB_ARITH_FIXED_COLS, NB_POSEIDON_FIXED_COLS, NB_SHA256_FIXED_COLS]
-        .into_iter()
-        .max()
-        .unwrap_or(0);
-
-    (nb_advice_cols, nb_fixed_cols)
-}
-
-pub fn configure_ivc_circuit(meta: &mut ConstraintSystem<NativeField>) -> IvcConfig {
-    let (nb_advice_cols, nb_fixed_cols) = ivc_column_pool_sizes();
-
-    let advice_columns: Vec<_> = (0..nb_advice_cols).map(|_| meta.advice_column()).collect();
-    let fixed_columns: Vec<_> = (0..nb_fixed_cols).map(|_| meta.fixed_column()).collect();
-    // Committed-instance column: reserved for committed public inputs; this circuit leaves it empty
-    // and places its entire public statement in the plaintext instance column below.
-    let committed_instance_column = meta.instance_column();
-    // Instance column: carries this circuit's public statement (global, state, accumulator).
-    let instance_column = meta.instance_column();
-
-    let native_config = NativeChip::configure(
-        meta,
-        &(
-            advice_columns[..NB_ARITH_COLS]
-                .try_into()
-                .expect("column counts pre-validated by validate_column_counts"),
-            fixed_columns[..NB_ARITH_FIXED_COLS]
-                .try_into()
-                .expect("column counts pre-validated by validate_column_counts"),
-            [committed_instance_column, instance_column],
-        ),
-    );
-    let core_decomp_config = {
-        let pow2_config = Pow2RangeChip::configure(meta, &advice_columns[1..NB_ARITH_COLS]);
-        P2RDecompositionChip::configure(meta, &(native_config.clone(), pow2_config))
-    };
-
-    let jubjub_config = EccChip::<CircuitCurve>::configure(
-        meta,
-        &advice_columns[..NB_EDWARDS_COLS]
-            .try_into()
-            .expect("column counts pre-validated by validate_column_counts"),
-    );
-
-    let nb_parallel_range_check = NB_ARITH_COLS - 1;
-    let max_bit_length = RECURSIVE_CIRCUIT_DEGREE - 1;
-
-    let base_config = FieldChip::<
-        NativeField,
-        EmulatedCurveBaseField,
-        EmulatedCurve,
-        IvcNativeGadget,
-    >::configure(
-        meta,
-        &advice_columns,
-        nb_parallel_range_check,
-        max_bit_length,
-    );
-    let bls12_381_config = ForeignWeierstrassEccChip::<
-        NativeField,
-        EmulatedCurve,
-        EmulatedCurve,
-        IvcNativeGadget,
-        IvcNativeGadget,
-    >::configure(
-        meta,
-        &base_config,
-        &advice_columns,
-        nb_parallel_range_check,
-        max_bit_length,
-    );
-
-    let poseidon_config = PoseidonChip::configure(
-        meta,
-        &(
-            advice_columns[..NB_POSEIDON_ADVICE_COLS]
-                .try_into()
-                .expect("column counts pre-validated by validate_column_counts"),
-            fixed_columns[..NB_POSEIDON_FIXED_COLS]
-                .try_into()
-                .expect("column counts pre-validated by validate_column_counts"),
-        ),
-    );
-
-    let sha256_config = Sha256Chip::configure(
-        meta,
-        &(
-            advice_columns[..NB_SHA256_ADVICE_COLS]
-                .try_into()
-                .expect("column counts pre-validated by validate_column_counts"),
-            fixed_columns[..NB_SHA256_FIXED_COLS]
-                .try_into()
-                .expect("column counts pre-validated by validate_column_counts"),
-        ),
-    );
-
-    IvcConfig {
-        native_config,
-        core_decomp_config,
-        jubjub_config,
-        bls12_381_config,
-        poseidon_config,
-        sha256_config,
-    }
-}
diff --git a/mithril-stm/src/circuits/halo2_ivc/constraint_builder.rs b/mithril-stm/src/circuits/halo2_ivc/constraint_builder.rs
index 87be8019a6a..1e6a1cce04c 100644
--- a/mithril-stm/src/circuits/halo2_ivc/constraint_builder.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/constraint_builder.rs
@@ -1,23 +1,21 @@
 //! In-circuit constraint builder for one recursive IVC step.
 //!
-//! `IvcConstraintBuilder` owns the chips the recursive circuit needs and exposes the constraint
-//! logic driven by `IvcCircuitData::synthesize`: genesis-signature gating, the state transition, and
-//! accumulator/proof verification. Reusable sub-gadgets live in the `gadgets` module.
+//! `IvcConstraintBuilder` borrows the chips the recursive circuit needs from the standard library
+//! and exposes the constraint logic driven by `IvcCircuit::circuit`: genesis-signature gating, the
+//! state transition, and accumulator/proof verification. Reusable sub-gadgets live in the `gadgets`
+//! module.
 
 use ff::Field;
 use group::Group;
-use midnight_circuits::hash::sha256::Sha256Chip;
 
 use super::{
     Accumulator, ArithInstructions, AssertionInstructions, AssignedAccumulator, AssignedBit,
     AssignedForeignPoint, AssignedNative, AssignmentInstructions, BinaryInstructions, CircuitCurve,
-    CircuitValue, ComposableChip, ControlFlowInstructions, EccChip, EccInstructions, EmulatedCurve,
-    EqualityInstructions, Error, ForeignWeierstrassEccChip, HashInstructions, IvcNativeGadget,
-    Layouter, NativeChip, NativeField, NativeGadget, P2RDecompositionChip,
+    CircuitValue, ControlFlowInstructions, EccChip, EccInstructions, EmulatedCurve,
+    EqualityInstructions, Error, ForeignWeierstrassEccChip, IvcNativeGadget, Layouter, NativeField,
     PREIMAGE_CURRENT_EPOCH_BYTES, PREIMAGE_NEXT_MERKLE_TREE_COMMITMENT_BYTES,
-    PREIMAGE_NEXT_PROTOCOL_PARAMETERS_BYTES, PoseidonChip, PublicInputInstructions,
-    RECURSIVE_CIRCUIT_DEGREE, RecursiveEmulation, VerifierGadget, ZeroInstructions,
-    config::IvcConfig,
+    PREIMAGE_NEXT_PROTOCOL_PARAMETERS_BYTES, PublicInputInstructions, RecursiveEmulation,
+    VerifierGadget, ZeroInstructions, ZkStdLib,
     gadgets::{GenesisSchnorrSignatureInputs, combine_bytes, verify_genesis_signature},
     state::{AssignedGlobal, AssignedState, AssignedWitness},
 };
@@ -30,56 +28,38 @@ type DecodedProtocolMessageFields = (
     AssignedNative<NativeField>,
 );
 
-/// Owns the chips for the recursive IVC circuit and builds its in-circuit constraints.
+/// Borrows the standard library's chips and builds the recursive IVC circuit's constraints.
 ///
-/// Constructed once per synthesis from an [`IvcConfig`]; its methods emit the constraints for a
-/// single IVC step.
-#[derive(Debug, Clone)]
-pub struct IvcConstraintBuilder {
-    pub(crate) core_decomp_chip: P2RDecompositionChip<NativeField>,
-    pub(crate) native_gadget: IvcNativeGadget,
-    pub(crate) jubjub_chip: EccChip<CircuitCurve>,
-    pub(crate) poseidon_chip: PoseidonChip<NativeField>,
-    pub(crate) sha2_256_chip: Sha256Chip<NativeField>,
-    pub(crate) bls12_381_chip: ForeignWeierstrassEccChip<
+/// Constructed once per synthesis from the [`ZkStdLib`] the relation is handed; its methods emit
+/// the constraints for a single IVC step.
+#[derive(Clone)]
+pub struct IvcConstraintBuilder<'a> {
+    pub(crate) std_lib: &'a ZkStdLib,
+    pub(crate) native_gadget: &'a IvcNativeGadget,
+    pub(crate) jubjub_chip: &'a EccChip<CircuitCurve>,
+    pub(crate) bls12_381_chip: &'a ForeignWeierstrassEccChip<
         NativeField,
         EmulatedCurve,
         EmulatedCurve,
         IvcNativeGadget,
         IvcNativeGadget,
     >,
-    pub(crate) verifier_gadget: VerifierGadget<RecursiveEmulation>,
+    pub(crate) verifier_gadget: &'a VerifierGadget<RecursiveEmulation>,
 }
 
-impl IvcConstraintBuilder {
-    /// Builds the circuit's chips from the circuit configuration.
-    pub fn new(config: &IvcConfig) -> Self {
-        let native_chip = <NativeChip<NativeField> as ComposableChip<NativeField>>::new(
-            &config.native_config,
-            &(),
-        );
-        let core_decomp_chip = P2RDecompositionChip::new(
-            &config.core_decomp_config,
-            &(RECURSIVE_CIRCUIT_DEGREE as usize - 1),
-        );
-        let native_gadget = NativeGadget::new(core_decomp_chip.clone(), native_chip.clone());
-        let jubjub_chip = EccChip::<CircuitCurve>::new(&config.jubjub_config, &native_gadget);
-        let bls12_381_chip: ForeignWeierstrassEccChip<_, EmulatedCurve, EmulatedCurve, _, _> = {
-            ForeignWeierstrassEccChip::new(&config.bls12_381_config, &native_gadget, &native_gadget)
-        };
-        let poseidon_chip = PoseidonChip::new(&config.poseidon_config, &native_chip);
-        let sha2_256_chip = Sha256Chip::new(&config.sha256_config, &native_gadget);
-        let verifier_gadget: VerifierGadget<RecursiveEmulation> =
-            VerifierGadget::new(&bls12_381_chip, &native_gadget, &poseidon_chip);
-
+impl<'a> IvcConstraintBuilder<'a> {
+    /// Borrows the chips the recursive circuit needs from the standard library.
+    ///
+    /// The native gadget is reached through the BLS chip rather than built here: it is the standard
+    /// library's own instance, and a separately constructed one would not share its public input
+    /// counter.
+    pub fn new(std_lib: &'a ZkStdLib) -> Self {
         IvcConstraintBuilder {
-            core_decomp_chip,
-            native_gadget,
-            jubjub_chip,
-            poseidon_chip,
-            sha2_256_chip,
-            bls12_381_chip,
-            verifier_gadget,
+            std_lib,
+            native_gadget: std_lib.bls12_381().scalar_field_chip(),
+            jubjub_chip: std_lib.jubjub(),
+            bls12_381_chip: std_lib.bls12_381(),
+            verifier_gadget: std_lib.verifier(),
         }
     }
 
@@ -100,9 +80,7 @@ impl IvcConstraintBuilder {
         witness: &AssignedWitness,
     ) -> Result<AssignedBit<NativeField>, Error> {
         verify_genesis_signature(
-            &self.jubjub_chip,
-            &self.native_gadget,
-            &self.poseidon_chip,
+            self.std_lib,
             layouter,
             GenesisSchnorrSignatureInputs {
                 verification_key: &global.genesis_verification_key,
@@ -260,9 +238,9 @@ impl IvcConstraintBuilder {
         witness: &AssignedWitness,
         bases: &[NativeField],
     ) -> Result<(), Error> {
-        let hash = self.sha2_256_chip.hash(layouter, &witness.message_preimage)?;
+        let hash = self.std_lib.sha2_256(layouter, &witness.message_preimage)?;
         // Compare message and hash
-        let hash_native = combine_bytes(&self.native_gadget, layouter, &hash, bases)?;
+        let hash_native = combine_bytes(self.native_gadget, layouter, &hash, bases)?;
         self.native_gadget.assert_equal(layouter, message, &hash_native)
     }
 
@@ -285,19 +263,19 @@ impl IvcConstraintBuilder {
 
         // Get the field elements by linearly combining the bytes
         let next_merkle_tree_commitment = combine_bytes(
-            &self.native_gadget,
+            self.native_gadget,
             layouter,
             next_merkle_tree_commitment_bytes,
             bases,
         )?;
         let next_protocol_parameters = combine_bytes(
-            &self.native_gadget,
+            self.native_gadget,
             layouter,
             next_protocol_parameters_bytes,
             bases,
         )?;
         let current_epoch =
-            combine_bytes(&self.native_gadget, layouter, current_epoch_bytes, bases)?;
+            combine_bytes(self.native_gadget, layouter, current_epoch_bytes, bases)?;
         Ok((
             next_merkle_tree_commitment,
             next_protocol_parameters,
@@ -478,20 +456,20 @@ impl IvcConstraintBuilder {
         // invalid) accumulator by a default accumulator that satisfies the invariant.
         AssignedAccumulator::scale_by_bit(
             layouter,
-            &self.native_gadget,
+            self.native_gadget,
             is_not_genesis,
             &mut certificate_proof_accumulator,
         )?;
         certificate_proof_accumulator.collapse(
             layouter,
-            &self.bls12_381_chip,
-            &self.native_gadget,
+            self.bls12_381_chip,
+            self.native_gadget,
         )?;
 
         let acc = AssignedAccumulator::assign(
             layouter,
-            &self.bls12_381_chip,
-            &self.native_gadget,
+            self.bls12_381_chip,
+            self.native_gadget,
             1,
             1,
             &[],
@@ -522,21 +500,18 @@ impl IvcConstraintBuilder {
         // invalid) accumulator by a default accumulator that satisfies the invariant.
         AssignedAccumulator::scale_by_bit(
             layouter,
-            &self.native_gadget,
+            self.native_gadget,
             is_not_genesis,
             &mut ivc_proof_accumulator,
         )?;
-        ivc_proof_accumulator.collapse(layouter, &self.bls12_381_chip, &self.native_gadget)?;
+        ivc_proof_accumulator.collapse(layouter, self.bls12_381_chip, self.native_gadget)?;
 
         // Accumulate the certificate and IVC proof accumulators.
-        let mut next_acc = AssignedAccumulator::<RecursiveEmulation>::accumulate(
+        let mut next_acc = self.verifier_gadget.accumulate(
             layouter,
-            &self.verifier_gadget,
-            &self.native_gadget,
-            &self.poseidon_chip,
             &[acc, certificate_proof_accumulator, ivc_proof_accumulator],
         )?;
-        next_acc.collapse(layouter, &self.bls12_381_chip, &self.native_gadget)?;
+        next_acc.collapse(layouter, self.bls12_381_chip, self.native_gadget)?;
 
         Ok(next_acc)
     }
diff --git a/mithril-stm/src/circuits/halo2_ivc/embedded_assets.rs b/mithril-stm/src/circuits/halo2_ivc/embedded_assets.rs
index b2d781d9bcc..77cd4474991 100644
--- a/mithril-stm/src/circuits/halo2_ivc/embedded_assets.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/embedded_assets.rs
@@ -19,15 +19,15 @@ use midnight_proofs::{
     poly::kzg::params::ParamsVerifierKZG,
     utils::{SerdeFormat, helpers::ProcessedSerdeObject},
 };
-use midnight_zk_stdlib::MidnightVK;
+use midnight_zk_stdlib::{MidnightCircuit, MidnightVK};
 
 use crate::StmResult;
 use crate::circuits::halo2::keys::NonRecursiveCircuitVerifyingKey;
 use crate::circuits::halo2_ivc::keys::RecursiveCircuitVerifyingKey;
 use crate::circuits::halo2_ivc::{
     Accumulator, EmulatedCurve, KZGCommitmentScheme, NativeField, PREIMAGE_SIZE, PairingEngine,
-    RecursiveEmulation, VerifyingKey,
-    circuit::IvcCircuitData,
+    RECURSIVE_CIRCUIT_DEGREE, RecursiveEmulation, VerifyingKey,
+    circuit::{IvcCircuit, recursive_circuit_architecture},
     io::ReadWithFormat,
     state::State,
     types::{
@@ -352,10 +352,16 @@ fn load_verification_context_asset_from_reader<R: Read>(
         .map(|_| read_field_element(reader))
         .collect::<Result<Vec<_>, _>>()?;
     let recursive_verifying_key =
-        VerifyingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::read::<_, IvcCircuitData>(
+        VerifyingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::read::<
+            _,
+            MidnightCircuit<IvcCircuit>,
+        >(
             reader,
             SerdeFormat::RawBytesUnchecked,
-            (),
+            (
+                recursive_circuit_architecture(),
+                (RECURSIVE_CIRCUIT_DEGREE - 1) as u8,
+            ),
         )?;
     let combined_fixed_bases = read_named_fixed_bases(reader)?;
 
diff --git a/mithril-stm/src/circuits/halo2_ivc/errors.rs b/mithril-stm/src/circuits/halo2_ivc/errors.rs
index ef112826985..c0a0131fd53 100644
--- a/mithril-stm/src/circuits/halo2_ivc/errors.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/errors.rs
@@ -22,18 +22,6 @@ pub enum IvcCircuitError {
     #[error("Byte-to-field conversion received {bytes} bytes but only {bases} base weights")]
     ByteCountExceedsBaseCount { bytes: usize, bases: usize },
 
-    /// Not enough advice columns were allocated to satisfy chip requirements.
-    #[error(
-        "Too few advice columns allocated for the IVC circuit: need {needed}, only {available} allocated"
-    )]
-    InsufficientAdviceColumns { needed: usize, available: usize },
-
-    /// Not enough fixed columns were allocated to satisfy chip requirements.
-    #[error(
-        "Too few fixed columns allocated for the IVC circuit: need {needed}, only {available} allocated"
-    )]
-    InsufficientFixedColumns { needed: usize, available: usize },
-
     /// Off-circuit step transition: the incoming certificate's epoch does not advance the
     /// chain correctly. The `kind` field carries an `EpochTransitionErrorKind` with the
     /// specific violation.
diff --git a/mithril-stm/src/circuits/halo2_ivc/gadgets/schnorr_signature.rs b/mithril-stm/src/circuits/halo2_ivc/gadgets/schnorr_signature.rs
index b7f5f9b212a..d430ca7de95 100644
--- a/mithril-stm/src/circuits/halo2_ivc/gadgets/schnorr_signature.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/gadgets/schnorr_signature.rs
@@ -4,9 +4,8 @@ use group::Group;
 
 use crate::circuits::halo2_ivc::{
     AssignedBit, AssignedNative, AssignedNativePoint, AssignedScalarOfNativeCurve,
-    AssignmentInstructions, CircuitCurve, CircuitCurveTrait, ConversionInstructions, EccChip,
-    EccInstructions, EqualityInstructions, Error, HashInstructions, IvcNativeGadget, Layouter,
-    NativeField, PoseidonChip,
+    AssignmentInstructions, CircuitCurve, CircuitCurveTrait, ConversionInstructions,
+    EccInstructions, EqualityInstructions, Error, Layouter, NativeField, ZkStdLib,
 };
 use crate::signature_scheme::DOMAIN_SEPARATION_TAG_STANDARD_SIGNATURE;
 
@@ -29,12 +28,12 @@ pub(crate) struct GenesisSchnorrSignatureInputs<'a> {
 /// equality against the committed challenge scalar. Returns an `AssignedBit` that
 /// is `true` when the signature is valid.
 pub(crate) fn verify_genesis_signature(
-    jubjub_chip: &EccChip<CircuitCurve>,
-    native_gadget: &IvcNativeGadget,
-    poseidon_chip: &PoseidonChip<NativeField>,
+    std_lib: &ZkStdLib,
     layouter: &mut impl Layouter<NativeField>,
     inputs: GenesisSchnorrSignatureInputs<'_>,
 ) -> Result<AssignedBit<NativeField>, Error> {
+    let jubjub_chip = std_lib.jubjub();
+    let native_gadget = std_lib.bls12_381().scalar_field_chip();
     let response = inputs.response.clone();
     let challenge_as_scalar: AssignedScalarOfNativeCurve<_> =
         jubjub_chip.convert(layouter, inputs.challenge)?;
@@ -57,7 +56,7 @@ pub(crate) fn verify_genesis_signature(
     let cap_r_x = jubjub_chip.x_coordinate(&cap_r);
     let cap_r_y = jubjub_chip.y_coordinate(&cap_r);
 
-    let recomputed_challenge = poseidon_chip.hash(
+    let recomputed_challenge = std_lib.poseidon(
         layouter,
         &[
             dst_signature.clone(),
diff --git a/mithril-stm/src/circuits/halo2_ivc/key_serialization.rs b/mithril-stm/src/circuits/halo2_ivc/key_serialization.rs
index 1b75c4a0131..179928cfe0f 100644
--- a/mithril-stm/src/circuits/halo2_ivc/key_serialization.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/key_serialization.rs
@@ -1,24 +1,28 @@
 //! [`TryToBytes`] / [`TryFromBytes`] impls for the recursive circuit's raw PLONK keys.
 //!
-//! The raw PLONK `read` is generic over the circuit type and takes its `Params`, so these impls
-//! pin [`IvcCircuitData`] and its `()` params.
+//! The raw PLONK `read` is generic over the circuit type and takes its `Params`, so these impls pin
+//! the standard library's wrapper around [`IvcCircuit`] and its architecture and range parameters,
+//! rebuilding the constraint system key generation used.
 //!
-//! Note: only the IVC circuit's keys are ever deserialized raw here (the certificate keys
-//! round-trip as the high-level `MidnightVK` / `MidnightPK`), so pinning `IvcCircuitData` is
-//! correct.
+//! Note: only the IVC circuit's keys are ever deserialized raw here; the certificate keys round-trip
+//! as the high-level `MidnightVK` / `MidnightPK`.
 
 use crate::StmResult;
 use crate::circuits::key_serialization::KEY_SERDE_FORMAT;
 use crate::codec::{TryFromBytes, TryToBytes};
 use anyhow::Context;
 
+use midnight_zk_stdlib::MidnightCircuit;
+
 use super::{
-    KZGCommitmentScheme, NativeField, PairingEngine, ProvingKey, VerifyingKey,
-    circuit::IvcCircuitData,
+    KZGCommitmentScheme, NativeField, PairingEngine, ProvingKey, RECURSIVE_CIRCUIT_DEGREE,
+    VerifyingKey,
+    circuit::{IvcCircuit, recursive_circuit_architecture},
 };
 
 // Recursive (IVC) circuit verifying key. The raw PLONK `read` is generic over the circuit and
-// takes its `Params`, so it is pinned to `IvcCircuitData` with its `()` params below.
+// takes its `Params`, so it is pinned below to the standard library's wrapper around `IvcCircuit`,
+// with the architecture and range parameters that rebuild the same constraint system.
 impl TryToBytes for VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>> {
     fn to_bytes_vec(&self) -> StmResult<Vec<u8>> {
         let mut bytes = Vec::new();
@@ -31,10 +35,16 @@ impl TryToBytes for VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>
 impl TryFromBytes for VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>> {
     fn try_from_bytes(bytes: &[u8]) -> StmResult<Self> {
         let mut reader = bytes;
-        VerifyingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::read::<_, IvcCircuitData>(
+        VerifyingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::read::<
+            _,
+            MidnightCircuit<IvcCircuit>,
+        >(
             &mut reader,
             KEY_SERDE_FORMAT,
-            (),
+            (
+                recursive_circuit_architecture(),
+                (RECURSIVE_CIRCUIT_DEGREE - 1) as u8,
+            ),
         )
         .with_context(|| "Failed to deserialize the recursive PLONK verifying key")
     }
@@ -53,10 +63,16 @@ impl TryToBytes for ProvingKey<NativeField, KZGCommitmentScheme<PairingEngine>>
 impl TryFromBytes for ProvingKey<NativeField, KZGCommitmentScheme<PairingEngine>> {
     fn try_from_bytes(bytes: &[u8]) -> StmResult<Self> {
         let mut reader = bytes;
-        ProvingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::read::<_, IvcCircuitData>(
+        ProvingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::read::<
+            _,
+            MidnightCircuit<IvcCircuit>,
+        >(
             &mut reader,
             KEY_SERDE_FORMAT,
-            (),
+            (
+                recursive_circuit_architecture(),
+                (RECURSIVE_CIRCUIT_DEGREE - 1) as u8,
+            ),
         )
         .with_context(|| "Failed to deserialize the recursive PLONK proving key")
     }
diff --git a/mithril-stm/src/circuits/halo2_ivc/keys.rs b/mithril-stm/src/circuits/halo2_ivc/keys.rs
index 5bfbf943306..3a694092886 100644
--- a/mithril-stm/src/circuits/halo2_ivc/keys.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/keys.rs
@@ -6,6 +6,7 @@ use midnight_curves::Bls12;
 use midnight_proofs::plonk::{keygen_pk, keygen_vk_with_k};
 use midnight_proofs::poly::commitment::Params;
 use midnight_proofs::poly::kzg::params::ParamsKZG;
+use midnight_zk_stdlib::MidnightCircuit;
 use serde::{Deserialize, Serialize};
 
 use crate::StmResult;
@@ -17,7 +18,7 @@ use crate::codec::{TryFromBytes, TryToBytes};
 
 use super::{
     KZGCommitmentScheme, NativeField, PairingEngine, ProvingKey, RECURSIVE_CIRCUIT_DEGREE,
-    VerifyingKey, circuit::IvcCircuitData,
+    VerifyingKey, circuit::IvcCircuit,
 };
 
 /// Verifying key of the recursive (IVC) circuit.
@@ -133,7 +134,7 @@ mod recursive_verifying_key_serde {
     }
 }
 
-impl KeyGenerator for IvcCircuitData {
+impl KeyGenerator for IvcCircuit {
     type VerifyingKey = RecursiveCircuitVerifyingKey;
     type ProvingKey = RecursiveCircuitProvingKey;
 
@@ -149,14 +150,15 @@ impl KeyGenerator for IvcCircuitData {
             srs.max_k() >= RECURSIVE_CIRCUIT_DEGREE,
             "the SRS must be at least the recursive circuit degree"
         );
+        let circuit = MidnightCircuit::from_relation(self, Some(RECURSIVE_CIRCUIT_DEGREE));
         let verifying_key = if srs.max_k() == RECURSIVE_CIRCUIT_DEGREE {
-            keygen_vk_with_k(srs, self, RECURSIVE_CIRCUIT_DEGREE)?
+            keygen_vk_with_k(srs, &circuit, RECURSIVE_CIRCUIT_DEGREE)?
         } else {
             let mut recursive_srs = srs.clone();
             recursive_srs.downsize(RECURSIVE_CIRCUIT_DEGREE);
-            keygen_vk_with_k(&recursive_srs, self, RECURSIVE_CIRCUIT_DEGREE)?
+            keygen_vk_with_k(&recursive_srs, &circuit, RECURSIVE_CIRCUIT_DEGREE)?
         };
-        let proving_key = keygen_pk(verifying_key.clone(), self)?;
+        let proving_key = keygen_pk(verifying_key.clone(), &circuit)?;
         Ok((
             RecursiveCircuitVerifyingKey(verifying_key),
             RecursiveCircuitProvingKey(proving_key),
@@ -200,7 +202,7 @@ impl KeyGenerator for RecursiveCircuitKeyGenerator {
         srs: &ParamsKZG<Bls12>,
     ) -> StmResult<(Self::VerifyingKey, Self::ProvingKey)> {
         let certificate_verifying_key = self.non_recursive_key_provider.verification_key(srs)?;
-        IvcCircuitData::unknown(&certificate_verifying_key)?.generate_key_pair(srs)
+        IvcCircuit::for_key_generation(&certificate_verifying_key).generate_key_pair(srs)
     }
 }
 
diff --git a/mithril-stm/src/circuits/halo2_ivc/midnight_backend.rs b/mithril-stm/src/circuits/halo2_ivc/midnight_backend.rs
index a5a770a9e96..b9491822116 100644
--- a/mithril-stm/src/circuits/halo2_ivc/midnight_backend.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/midnight_backend.rs
@@ -4,7 +4,6 @@
 //! `BlstrsEmulation` — its self-emulation of BLS12-381 proof verification. Isolating them here
 //! keeps the dependency on the Midnight backend in one place.
 
-use midnight_circuits::ecc::curves::CircuitCurve as CircuitCurveTrait;
 use midnight_circuits::verifier::{BlstrsEmulation, SelfEmulation};
 
 /// Midnight self-emulation backend the recursive circuit is built on: BLS12-381 verification
@@ -16,12 +15,8 @@ pub(crate) type RecursiveEmulation = BlstrsEmulation;
 pub(crate) type NativeField = <RecursiveEmulation as SelfEmulation>::F;
 
 /// Curve verified in-circuit during recursive proof verification: BLS12-381 G1, on which the
-/// recursive proof's commitments live. Its coordinates are emulated in [`EmulatedCurveBaseField`].
+/// recursive proof's commitments live. Its coordinates are emulated over [`NativeField`].
 pub(crate) type EmulatedCurve = <RecursiveEmulation as SelfEmulation>::C;
 
 /// Pairing engine backing the recursive circuit's KZG commitments (BLS12-381).
 pub(crate) type PairingEngine = <RecursiveEmulation as SelfEmulation>::Engine;
-
-/// Coordinate field of [`EmulatedCurve`] — the foreign field emulated in-circuit for BLS12-381 G1
-/// arithmetic. Larger than and distinct from [`NativeField`]; not the certificate circuit's `CircuitBase`.
-pub(crate) type EmulatedCurveBaseField = <EmulatedCurve as CircuitCurveTrait>::Base;
diff --git a/mithril-stm/src/circuits/halo2_ivc/mod.rs b/mithril-stm/src/circuits/halo2_ivc/mod.rs
index 53a561689b4..f0caa5a2b55 100644
--- a/mithril-stm/src/circuits/halo2_ivc/mod.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/mod.rs
@@ -14,39 +14,24 @@ pub(crate) use crate::circuits::CircuitCurve;
 pub(crate) use midnight_circuits::{
     ecc::{
         curves::CircuitCurve as CircuitCurveTrait,
-        foreign::weierstrass_chip::{
-            ForeignWeierstrassEccChip, ForeignWeierstrassEccConfig, nb_foreign_ecc_chip_columns,
-        },
-        native::{EccChip, EccConfig, NB_EDWARDS_COLS},
+        foreign::weierstrass_chip::ForeignWeierstrassEccChip, native::EccChip,
     },
-    field::{
-        NativeChip, NativeConfig, NativeGadget,
-        decomposition::{
-            chip::{P2RDecompositionChip, P2RDecompositionConfig},
-            pow2range::Pow2RangeChip,
-        },
-        foreign::FieldChip,
-        native::{NB_ARITH_COLS, NB_ARITH_FIXED_COLS},
-    },
-    hash::poseidon::{
-        NB_POSEIDON_ADVICE_COLS, NB_POSEIDON_FIXED_COLS, PoseidonChip, PoseidonConfig,
-    },
-    hash::sha256::{NB_SHA256_ADVICE_COLS, NB_SHA256_FIXED_COLS},
+    field::{NativeChip, NativeGadget, decomposition::chip::P2RDecompositionChip},
     instructions::{
         ArithInstructions, AssertionInstructions, AssignmentInstructions, BinaryInstructions,
         ControlFlowInstructions, ConversionInstructions, EccInstructions, EqualityInstructions,
-        HashInstructions, PublicInputInstructions, ZeroInstructions,
+        PublicInputInstructions, ZeroInstructions,
     },
     types::{
         AssignedBit, AssignedByte, AssignedForeignPoint, AssignedNative, AssignedNativePoint,
-        AssignedScalarOfNativeCurve, ComposableChip, Instantiable,
+        AssignedScalarOfNativeCurve, Instantiable,
     },
     verifier::{self, Accumulator, AssignedAccumulator, AssignedVk, Msm, VerifierGadget},
 };
 
 pub(crate) use midnight_proofs::{
-    circuit::{Layouter, SimpleFloorPlanner, Value},
-    plonk::{Circuit, ConstraintSystem, Error, ProvingKey, VerifyingKey},
+    circuit::{Layouter, Value},
+    plonk::{ConstraintSystem, Error, ProvingKey, VerifyingKey},
     poly::{EvaluationDomain, kzg::KZGCommitmentScheme},
 };
 
@@ -55,7 +40,6 @@ pub(crate) mod accumulator;
 pub mod bench;
 pub(crate) mod certificate_proof;
 pub(crate) mod circuit;
-pub(crate) mod config;
 pub(crate) mod constraint_builder;
 #[cfg(any(test, feature = "benchmark-internals"))]
 #[cfg_attr(not(test), allow(dead_code))]
@@ -80,8 +64,9 @@ pub(crate) use types::{CircuitValue, ProtocolMessagePreimage};
 
 mod midnight_backend;
 
-use midnight_backend::{EmulatedCurve, EmulatedCurveBaseField, RecursiveEmulation};
+use midnight_backend::{EmulatedCurve, RecursiveEmulation};
 pub(crate) use midnight_backend::{NativeField, PairingEngine};
+pub(crate) use midnight_zk_stdlib::{Relation, ZkStdLib, ZkStdLibArch};
 
 type IvcNativeGadget =
     NativeGadget<NativeField, P2RDecompositionChip<NativeField>, NativeChip<NativeField>>;
diff --git a/mithril-stm/src/circuits/halo2_ivc/recursive_circuit_verification_key_for_production.bin b/mithril-stm/src/circuits/halo2_ivc/recursive_circuit_verification_key_for_production.bin
index 8e1cff5ad0675ec0ae646b41d88c2a74d9888ee8..89b19f59e410655c5ba1a8b2a00ce042db797b82 100644
GIT binary patch
delta 1407
zcmV-_1%UddFQzY$W?&O}&_QuKc({%?sp`c^9>k7=R}v|qunmoHOPn?#9Wt2Z+yNQ>
z-%gSP66ZhMwNMZd$C?(HY$NSYE0D?!A*=<)ZQ<Pz-E^2<0Y{n!85Gifu;l~kG*n(r
z0ef7FQR|V$V1EzGYu}m_qYmgG-Bt9p;{g4WQ<2*%N8r2y`qoHJZzn0Zc9wETr76Jn
zMb?yct?m+LLI3#K?)RZJ08$CMJa6c$%63v3-QTM0#*1MXK1VWIT@{B}Trhmip_=<W
z_vIH30=T{%5=qWAnu-oGZ@mq!g{NkP?+C^Vpc611(0{=6jf8o6{69DBD9#tI$%4HJ
zaikfiB8}Au=&9<#Ed@EBn>qln`Rjtqn94?S7UVL{;?zmDB2}&{7fvqFilS=)-)ebM
zA$X!aP|A{<jA&)kS95JoS#0mZ2_l~2p<MhR@R@G8l0OOC7S0*}HWYgglcRAhZqq5g
zB5;(nZ+|lTnxz7tSL>D?+@Vfd;~ysbyySWSt+@zgWOuJ%JKbDG4z5}QL#`NS>Gglu
zNnZSg%XZY_mllK}gVV$v4~rGtsw73<?h4oE$uMWo3+pO83l9<$Wte0=+P>$>oQ3l1
zg(PJKyWqXrTupgyiQ598$mFFGLS$>FJKPt(cLU52JCmjYV1EhMk|zFk>Vp5JJ)h}&
z^va#Gg6rQh=9zCy)fx^leX1x$jr8p%!BF};A+XJbW6}ty?rqPeZphL53UQACK>7lq
zqH8h=TpR#;Qfei?8-InMDR7gi9qUU{c$T$PP}dP(ZW!TVu)8E7Me3;k(6x=@_i6$<
ztnH>bOFhitRzYw;;#Vi8Cswi0f&oWfX~0Gh4QQG~m0@rxfKc{EMRY%ortc!bIY+Iq
z>3rEYEItVo7LB_Hz?+H7?WRtN>e$V*#seS$vql9V0h8tgV6$chpaQdI41ffarVGHc
z1__`7e*!JnY;Gqbq08$b8q2YPu@o7f5coTT_(9B4f%y?e>Z!Fc07!alECb;TMyc~m
zc?IVE4fto&{Qe+zn$RXXfjPvWlcWrbNW<jfl0D3PYoVNTgc95)0na}^P&#m;s18YY
zXq&&R<PiPG{3&iOcv-bEvC5I-9!M!hcLRyxfBFdmY}GQKk$~sG`QruRWn~A8?RM8G
zg1uApPm859kM62*z?wbiTJZs>5V&e`F>q#MFPPVUIZzAVejU67U3&n8rfhhxF1s4s
zHVMcwUo!z`J!r`i54GMDv-8-G8<Rv?4;y2IU0jOmE0+l&!`}h0?+v(uw0V1TkW^@q
ze{nvS8UD&~84i%BjnPdR!Bb`(MDZGMVYA?H%WGRxqCe*WrKKkPMXIMK_H>F+bti<&
z3QAi+R!10msb-){e)MKYj}UoyNDLX^=nh2i53f56$A9XmLfnm37rCp#>k}NJ>A52=
z)~|DI(7$$S6<GtnU9Hp89Ks=Kw2{4je<AN=3ETDJIw+4~Zwe<emL#zuId@<$`5u#S
z;@3v<<Xms}CRip`OW$ns-Gr-#7Qw?t4@vfff!tz3!YElaF)*L<w0GPZ_-%Vp%|;(y
z$hM?4!bKTK@^C+b&v3_>%L;5n0(=wH45567g`5k<oY{%jKPCe05y9skUJn8NM1u7%
ztAT84$hQhYpt-X)Taf5{zzGtIH7C1^N5uIuDopcOZFcK4=Dtr)hNc(Xh1RaO!nn1)
z$e;H<6HgB+j04av2(u;=Ap~E&=oFzK=x0}nNRx;_B4Rq>V>1cv-X-`7;M0J=So-Q_
zLp0gF`qB&jZk#EM9ef9BJ!@UTZra3Vhv2i^X``d#`G7CSCVkN45~~K()ziTRE5AfF
NLn!e~_$?*gA`~eAqHF*F

delta 1407
zcmV-_1%UddFQzY$W?&V7TQfoT1-HfMBQGQd`rdFEDj|zRef?e|0LsJuVGcTB)MM)1
zm^SKd`C@aM5q}sV<`EnG4d2>7d|HaZ+!@)6GV8YvagwbvQRxB$M|;Hsde*>dV%?sw
zt7uwE+8U9@V1EOeTc$AmR6%v^!p`0&bBrS!xH*L}lOJ7~-jCgM=ktChCxp)w5jbn^
zb@3h8R&5Eu$F8cTcsS8gv6_QrRhC$m!}KB6wHYI{uTQ%9`}>d5FxrR&5<eLtN?aQa
zy6pl>7>Svlamh=Aim;TH?6|L&z?1nrNeQqa-|B=AWPesO7druJih{UsvK@o$$0(Kn
z#CaH4KzR@UtJ}k1h)@2JH>YgdOuTv*j^)iF^qCI}1WYa??EHc&JXC-J29p>SX<Pe(
z#K>Fz+n;Xm>F9UC*(=c10=)L)?7SD|#6=Ptb1fi@E4gZHno6y)bo#;oOK0=C%Ql&4
zi1c|u9e*u{VzIT{-elmk?oJDTJg&&ivA~bx+k<#RSJw0dhySfh1RH$GFys=RK%Sr1
zOmpkPW->c^I5~HiseC#<3j}#t41M7sgC=r~0e*ICq6u1N6RbkkZjRfJM)1W$-3WGi
zIxCnwd2U{AE{;_>7RkIl<Kr)=bGyk|tHP=Abpu_4sgtGxV1E~=7?xY>X#hC1)ITi@
zWewxRlkM9pe0O$sKY%5+nVdA3`CLPMgSryuKPnT-2+|qzT11!d%3l!c<2H~QuTo<L
zZYuNT50Y!~`J51oT*$*%Hrjz&d5sMAUtb4#9UTnusoCpw8O64$_j{dYH{EJ?j6YV%
z{&Ci<pxj)-E<rtw_j<MB#Oxbq^_g`A9lr(@P9ab3E!y+~#{OHRg{o%C1erMh83|S4
z3<KjGhNus4@fa6($(nCYOheG><)0?A#seS$lLiK0v*rXK0kdWXpaQc-4xj>)h7G{8
z1_^)!e-tn}YeWmg<%{<QRC7NS5PL1KC(l*##avN_t~L`oM^^a4B~^y{_{9)f0gB9{
zm>K+#Y>~%8k{B=2DWeZm*a=6W`-j|rdsMcCr`;?6D@f}2v)&HNYdsj8eNSJ0j|2o^
zR?kb13HW|k!KK{?-{+tZbkLLeY|8R;<!;NJf6uVRn0}xCqWEQ_%fLczl1>(0UEwiz
zz)xzd;j5E)E2M*<HRE?AO{pX|tQ91$&CC;R;27XHvj;vt$C4xmmlyy(rq{yTRd4bl
zmiZmU*PmYmmJ7}P(fSsl@@P1KrKgU8cfN7HbvCGUT|Je=<dY0dtgV8Khn(vPxyv<)
zf5)E|%+p}n25#XvX7HikTkKcV4(LU@j3*;%3^d5hHxHBv3D=(JcB&b_8E~;_mVuz3
z%dXcFxXvmrCk~<cF(9_KSd}v(Oe}bsFF=?-&7+_ec@e;%|7uxCB&mKROsu`=53BX|
zPu*I>r|OJ&b|`&F_upmusXif#D&|B{f3zfr4FkjPO&v^tggr*G<nIW)g*wB;U_<SO
z^`ZO%2<_M<|56uIo!c)w?t4jxCl8Oa2WIGF#U!YF)svsB8s=PsV^%;chaC78IWfnQ
zt>VN?HF&2Q03-jd=SP4W9X#)z0V4rmmg?)3IRyIKZJH)t!qsTa9N*CeTV0>JL^Dld
zkgH)lnmH||Z_l}EZZGTZ0vFyBeoL2HwkDa-<yK3|)7NKvj6X!Qq+PYB!i+mKEO7>w
zs9d79=!Ea5ae7X7QnMx#Ap~FFPXK7V(r6vYO>}tFO(k8!ijo*s|B?B6N%?Zyy}FC#
z@nV!w8AWy(YPDaJqCN&YJ^C^aL|sQHV=vT=#;MSqkk@Wckh63sTNx8i@H6;peEnbl
N{_SVHzsTD;$lUymukQc=

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/genesis_step_output.bin b/mithril-stm/src/circuits/halo2_ivc/tests/assets/genesis_step_output.bin
index 6b221c963d203c43f25d8c2b6d8b898b8684dddd..14c5a19b1e359e3694d3b5c05af03da7250e19f0 100644
GIT binary patch
delta 7611
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

delta 7611
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

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/golden_recursive_circuit_verification_key.bin b/mithril-stm/src/circuits/halo2_ivc/tests/assets/golden_recursive_circuit_verification_key.bin
index 3ee23f0a98543a787aa283ede2d5a4d70e351a99..c57615eb5e7032a05acff4aef160f85996c0268b 100644
GIT binary patch
delta 1408
zcmV-`1%LXcFQzY$W?%)v)GsadUU^d$AlbjjdGST;F2me&2X}(tqXKH^329oy*9MCn
zs@AWP_kR}tc1#XXybH#J8eb=MQq}c`--Is8SCYh9L}#;mc1C`B#M(Kl0Q+a!$K`^=
zh#$V9H9L{UV1EE*L^At@b9Af2J{~8fos*_3@(D;aOU=uI*aw<5Jh3bs!<u;fn?mcj
zrZE(bO@9y=82KG@2+Gxpe6k>d?<93=fzvSXb9nb)VLCdd++p94=NV8DUB*Kbf1tsc
zpr95B5r$(FU9AdXn?DOjO8ZcWs~1G4aGz}e2o!o<z<=jK)?rO4F|9fP&<6?|rvjZ7
z_sRlC!IFZ02hij!dy{I>lcxZUhbjc*-YMy{3j%)#m?e#ZnJrtn?%Riu2Z4nL1jXZ!
zOXtI20drS1s;8Ac3#Q;@L6Uj%UEb!8kZX=gyPvYrDgdAL@J80+_&=TtU=xowhuqZ$
z)PrdzL4SBgyVu9CCE45b>KC|nl|wg~m-B5%`7(M!7V1--z?Rbx4NliAMI(_MXTFln
z;*dKcCumx_tvcceadJXyh@fCedZXjk4AA@{u(C%6e0yAx4O(aPPL(^O1DM?r&v#>)
z+5tk=LwRLrCI6#rr(9ObIYyg|1OWK6e}eaXQUmK7eUqjFV1F4>H0DwgCh#cF-2fi4
zSyB#3%k5y1;!z(Bj|g&FUxhh^iF~Ps+R7|*)cBd_KV<@z4!up}!Na+u$_UxRPHN)w
zr=iC9!4P3{UYtppFVxKEL^lN0i0S<%W|z(<6w?OWOC}hA>+vhOM%Q?kZ^a5T`21Yi
zk!&H$!h#-F4?#PnCWLU%y6Qs)UXgV$M7_=k4D;nc9CUMXRw~fngvO%F6mfl4w4fcL
zwz&ucTO-fl)xG&POHCosJ?p+cLXPCK#seS$vql9V0h8tgV6$chpaQdI41ffarVGHc
z1__`7e-j2*uRHY|PZ;8>4sdAIXtP>6Dlnh#Rt`tGfnL&vtEKft-K57q;_RNZskN)^
zn+K@y6TEXEsDQXXd9%0C-wCzX97pG*D()fkC-jGi@`!3)UCcR|@H7fA7x5=z7zc>{
z1PNaVX#oQx^oIw!uW4YjOhQjc`;oL)cvA~(f3xBsTYyrK!m;h|g$OIAK%5hxdzk*}
zvo!pK%+DEjqUFKfsfN!)^^Gw^mL=a}JnP05g5sagu?Qx9|8M?J$R7%E*W8pNI#arK
z4*R0ou9p%VAw_RG$40%$)6ktt(5qPRSv7irn0=x$kR*V-t9uJZOFk@vpaf%)B*113
ze{Ytpj$tqh-wwsUY?rOGcUXJLB}+uT##Rn8v=-_(QgW*oYCzqo-vA044>h!{I=t0=
zvv7gc&^J4yJ9ncP=GY_v86Jh(Cghug%AeCy+YFKh)qaNAC4&&8l*FU;O)+iuV1gra
zCc7HGW{Qmd4IGs9CpXDss{R@Z6uQ)xe=pwr7PDo19PPx_ieJhF*k95|dIF4GPdG~v
zqR8m`vLMPLNGo|YdrQrZcm>^&Dnf**0trDC1!bZ54|$ON7E1~$h-<oOe{Zaj%8|I(
znD!9g_-UJE)1p$h&#yq<;8qyu1FcQo+ptZZ=)+9DQ{{5VWi`U$-NFo(KXb_YL}oho
zV0>AndTC4T_`BZ57bjbt92lHe41>19A*XBc$>nOgnO30v!E-74S3G|2Y(*Pr!b#^4
zT`6)O8MoTmi|V^(IkP4cAOv6r*6xgGC%T0Gq*1afA}}khpQo-tEEM6D>4oe#kEJ}x
zH2mItSvtUu%@(D;7S=%z?{#M+s1ZK64O}j}(T}Yq9S@&~sF7wz!0F5HENx^KjMp@`
OTaCFxnVRu6h1ioN`Knj|

delta 1408
zcmV-`1%LXcFQzY$W?%*l3VUMbeP3nSVRfF!`ykdBti!T<z`n9gq(Z9nNtgGLOxX0i
z$=V8X+s}60q!0q@rngZ!{n>)%jzD>zPfOcV*;Kes3pfl7fC~zc+_d|!+7-U7WqIyd
z6_sNQ>AR7}V1EOFe4fo3M0=Rs&9qc`ns0K{8ICeDLismJZ8A|RiJf0ZMJ;MQ)<yPV
zySe4_xC{s&chNRNRt0MP6AIvP1D6l729QCkN3D8NPHBmWgyNb8yf@Al(Xu(pDTd0i
z!iX1-z0rb?y}`NdFYSsI%|d>O)XN}dYL7>k)2hpZYJW?PG`xVNAem4krN}PF`3>X+
zg*b{uq=~La=U@~H{Kv1Pi~6GLb(S45a+Wu7RICVT6Bgy^W_Zxi%D74C4Htj|M9zeW
zyC4@W)$%?}c*>E;$+eR}jV>%$$r#YSBpT1nm$df{>C3`7&BjkUYN7rYB%|hr=at?9
zxNX_ZC4c^flJIAI67tn))ULwU<4YKmLSHx385w;4M<5xSPr3gJ89YqlwNi%Aunn;1
zU~IO;d+Co5i#QFL<COqiGc^j=ipi&M@ie2g-2?LG3;sDC3$gwhblVR7Eq+m&QRrz|
zT8i_gf}%MJOX^Fh{|^cmHg=%VO3VDDgcuj6(F05l$&;o6V1E{*Dp?{~c<q%o`{*?y
z+0=+3!Y3_vblPl-F^JR^m=@E%4ta{!=A@;sD`w9iy21ciiUDkCET-~`u1%8(c_wZe
z)U^G?J$lvtD09(iCV2UipzeY}-&lg*K~xDxlfMj?scIeqY>&o)s=GU8+i_DFXt5*X
zM1W!CQ@A;fDM7st@|<ZxJ_%|cK71DurC+cWIDTb><VX?)?F*u$(bg|Lys0@dp1Sht
z&7Ke`p{u;l!jO^SxGI`=U2Uc6NO$+M#seS$lLiK0v*rXK0kdWXpaQc-4xj>)h7G{8
z1_^)!e-cH*&`M(21^FB6Dvj3IBQL<>8PTG8A}ELUI3ZBQ-GAI*s*v~7W@&uz{Xs-A
z9TFjw`v9%oD;Gb$NUqAWC>4c5NFA3GdDV52$w!O$WW1l@bWKTiuMZo-MoO$2yA&0z
zj6I<buQ3QeM7z>wxAmGIN2Yu$7oC4g^we=+fBAaVL*}oshdxo1S8*ijC!ZJ-TM&<M
zJ8=Uk1x0DwG^<keHMuw));J25HdFN<o(Ed&`l2$GjL~|!iuPc0CDIp-XQ?g*(~h&=
zDwrV28TS<<7*oBP;YI?GY@IV*RW<vyhd_KVKUuiw*OkKvOKKHPb?O@;Tke@-K_FzX
ze>+@M8$SX+`aGNEO<#jM{VX`4Zl%7w*ivy~v0!p*K<iow%>1=_QolX+{zct)Y=duA
z-@=Tmw6VAOu#3V!{Q@lp)kS-Ap%Zg4Kx5RyyZL1da{5FnVRKevr#;Nm=U2bCsk9TS
zdQU(LPrgzf9}GfoZ{vtpvWn1D5iIi{e>c4S3$cVTl2vSOVS%`2&K}nXhy7DE+iv!M
zwz3PXK`^aN_(ENExr0|-Zhx)pJw|4K7liZ$VeSrssUEO>bB0D8Bhz0h_}x9adQ?@x
zKy`-sq-_qyBG9w5xq#&=l&kDo6LR3T!ieH?4M!k=f7eyDT3S4J9%j{ab;Mv1M6VNB
z(gB#mhumDhq{{^2Z3=2GjtKX+hN^l$`S-6iMW0iXy<%WaX86(qyU0aa?h9=BOqWrR
z=_!JeUp)a7T65rS4YMW_AOv6yyv2GR|BdmNNk}@I&+yXj>56gR8$E5EDCJ()1!kAZ
zLaXYv$S|<an(#<nZ4l%TWm1Uoua(EgF%Pvvl6wcEe|N>}Id2q4$N)b%3PtadSnLR|
O+OYz)VP|0$a4Fx3+p2W{

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/recursive_chain_state.bin b/mithril-stm/src/circuits/halo2_ivc/tests/assets/recursive_chain_state.bin
index 0850bcec11ef3f6010582c5f6251a2863a3e6622..b337020e422d590f04f6dfc24e836e3445970e74 100644
GIT binary patch
delta 11506
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

delta 11508
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

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/recursive_proof_accumulator_bytes.bin b/mithril-stm/src/circuits/halo2_ivc/tests/assets/recursive_proof_accumulator_bytes.bin
index 9d8e88100c6c5c1b885b709b523fd18c9a763e62..a0d86f42ae562adaafffcf4636cdc306f14cc631 100644
GIT binary patch
literal 10397
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

literal 10397
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

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/recursive_step_output.bin b/mithril-stm/src/circuits/halo2_ivc/tests/assets/recursive_step_output.bin
index 1fd65ae13ed22b0f7d4e4058a4d8048884f2c75a..82c6ef71a251d9ada3d98ce26ee039996b11f693 100644
GIT binary patch
literal 17469
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
anqVVm2L}@yCp{B8TO;%T(GmY!;Qt2f{FvPU

literal 17469
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

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/recursive_step_output_accumulator_bytes.bin b/mithril-stm/src/circuits/halo2_ivc/tests/assets/recursive_step_output_accumulator_bytes.bin
index 51d6901bf483c927e8cd0fe54b8230a5223b65bf..af2022931247109c5ba6ac6fb10c90dc8a4b1d55 100644
GIT binary patch
literal 5759
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

literal 5759
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

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/same_epoch_step_output.bin b/mithril-stm/src/circuits/halo2_ivc/tests/assets/same_epoch_step_output.bin
index cbd3b6135c559327ff9f8c5727d9630a07c0707c..d1586294ee53fe636b1610947fd333cf0dce4a3e 100644
GIT binary patch
literal 17469
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
HE%<)`eA#Gb

literal 17469
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
L|EnYZZ-M_8XOCB2

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/verification_context.bin b/mithril-stm/src/circuits/halo2_ivc/tests/assets/verification_context.bin
index 1e29cd458e91c5ba8bae49c6c3de5814acef91d7..d08b7d3322e80dcabd8a4fa86fa523058eb1d27c 100644
GIT binary patch
delta 3134
zcmcK5do<MB9sqDNGMSPg(u}uaD$i+N9>=3J%?dd}M>@i9Jcd$vhmjdX&SeO@OAlhS
z%u*gb#v`OgVO*2KnXaU8$mH2EE@94X)}5Sl|GoXu_1AZ=z4uz*{at(S@298|R#XYg
zPc=*hr|w*cM+A1%i+?RS>LtFGBBMt|cW=99U*$v(4mT($r$g{FQ@T}5t3-Ad(rct=
za2d*xg=?lK6#U3!baDN4V&38ro%MnY6HkSv{O6lF{pv^S9#t6fDTL>%{YIL996Dyu
z>)8}ul^k#&TfjJ+cHyYOp!D-Cq-R_`{jG*wK>|2$0kJgCXMg#JaSB>NB;{N+wRU<#
z8SQ&~PEa9yu?soExA(NPMn6n0J@w<u(`svm*|8thBBPt08irfc%h<lpCe^Anr1yW$
z54kGpxPMr^dQ;r{MulEqfrIQw?=`_#yQ@np%1djK(~2A`9`CoGHTKCkA#3(QO-*}T
z4Ks)qd}?3~4fas@%G>78aCTisDLIDvVfJu;ZtD(D<%{Fn*gICfOn8<DoIUGJ2@YkU
zOX2q%iBXJ<%)+jm-*23x2wiHdHS4rx18t#yKSo2GY+mAt9Cb&7yboT^#7!$v3pm4g
zvxS+PDwt4VuCBJ3Uz8JF%W!r=?Q?9+E%xI_+(DL=(Ytet&Iujn>Y~)*u9?BchbGIl
z-tM@YR*MSlXJj@zyVcKLy!0^x$LiD{N>>r--(H{w<Z%w~i0=#um|ZD+Ggs}m;vS*~
zBg_qJG(8kzv*F0nh||Kh<Cf{tfn5U@Aqdyb)wffwxLXauBgNiv!@pUQMb&X9Detj1
z6HbavO}>Dt2(h-ixeQ<Hcb}a9X)0{rAf=jkLaIl}!<KYw)&XpqU822*r)NrwtJLd0
zw-(iSdq~4Y;n1zB6;20l@%ivR8s^>#wv6k1yQEMo>+lfgH+ZNbt<3ZH<cO~e{DECq
zGvb{a7M(gPF>9s{CKg9_ZXvAx`_xduStH@IbbTMx!5=EI8Bu*LGlviX1@Sma+e>AY
ze@!0Hjf;)(G3^`8=&BHEMyL4Hm+MtDHY+Ro?S3`(x^0c@=5EyQF#E*OIqw7D?1ezr
zCO*hDg#Z=72bYx~ATxt_^vwt0JjAxtO`wJV0j>(f<08x9EH(SRll6^@b`eb#4O#w)
zah5?*a9<|vnT;PmDIz9Cf%C>XrHt|Zdg3{hV2f%STw#CJNBw(2EBBSHjxZ()R;_g(
z|D+JCK2&y_nKl!M$W_=r^X`>FiS9!43qd`PKD5<M!rgpkAgd><_R{fZ)uh+wQS8^O
z{H+Fo+`N}9$}H3>d(+beZRN1sFn2AtrPJoBI^}ct6Z9uV&vQ!!#yY!YnRR2sN%&%v
zq$WCO=N~#-yzJaEHCv4EXG6>O)Lscw{}4Cv<ZmOAe(1uLh6kjU-<N-z)`{$z%(~uE
z&e&O{HGj8UTru)Nzi~1?hkO?-B5O_2(bKU+Q<GozaavirH?M?f*+O+}|F^TjkEHZP
zTFr`XkDJm24&fbQwRTeIsWK|S&=7Uz!%Oz9FK_phx-9dVvv(8pXg$G4e^Ci*pE?+t
z?%_Hye}w4XT#T{`+`+@{R!zxVxR{*q;xSz!JCaIv7+qV05i`}duby*!nyEN<Sxh48
zn5U(iAz8~F16%bJcC}0X`Q^@ygE01vz?!9T<E$h;OTb&xTVkM{N-HB@i5HVC7NRO5
z#v{Vk(oi1KT9F8Ty3V8!jJJE)Njm1W#gD{fS3i@vPV}mN)K$sx6Bf?QJ$|bfe+}$f
zK{T^UT|0L>@GKS_Wl*UssYzmQ;rf;r$4oM%__t*H6OlbFy`L`%TAkSzOR+npn>Bca
zi4!Ts-IP338D_dF4T)p7IiB8XeJ6xn7@aDZtyStU%&(R)nV*D)MY%bk&jjLOHTjB=
z#)BH42tJ0oK-xT0GQJ|DWxvplDDtI9Jn$~mK_`}mv6Lnf@y%CrK6R}0>8z=1cv;4s
zLom$@W{*c!-fxUj&LgVn%pD?UXqwbo4v%e7?S1mP^HRi(J4{$~@bxAh6+MR9_>K(Q
zr_C$h8v~PnA_j~Il+74065t{rFkz+*Bd>p{7*lQD7qd5t0I>}Ma1sWNCjmWD5*$wk
z*S-d8fK`P+ELpx_1M<l78C!s~hG1IY0S-+gY;?Z|1q5vv4p32$e53=CY?9yvJV2;H
z;J7UYP9T6tTlowT%zO<bfK~sx?`v%}1P06+>>)B>Hh_zS00}4GZVQg#{(E%dHz@gT
zNdRmg22R8QAub6{+z+Vx<pB@czXk%Z$3uUv6TyDMUq=ceeIGvGwrBm)g2)?6kX)ek
zG+^L|WZFhE^ye$I{f0*0k5Rb;nugnGVnDeA2Kt6G-^~nw9l-GLjwd$0$H~h<)9~NN
m+P76(&qCNx+vK#ZXCZDhaO+t}|BJc*i*oXN;Y}WTp!y$tzu30`

delta 3130
zcmcK5X*ir&769P-3PpmHwWvxmcCkb$rK%|Vo<=j%F=RA}4^fub*CwGPZHY#Z8%uPE
ztr!X+g^<J=p(e4D1?enAqAek`SYqjlnfW_@7{AVa&V9b;-22?`oHvUBWig=iSZVf5
ztB>?-d792*w4B`|rsh+wRo{=yd)xVOBSzUdDmobjG+5~O_jYO4#xLx0>{Ub4hX!xq
zQ<BP9RVOXRQst>_GTyqa^boR>ev-ETiD`^ZeIh3RwB1_zPmL*TWvS(y5u=a~g=l=L
z$kmtyy_=mG9!@Fa+pM^Xp|~$3^UChDGi>0m2Gd0YEryrkXOcUFr5cC)WW6oT#%$e0
zd6!mdW<8TGvE>nS>6^U%e_U61AUD|OQ<*4Ak_dT;@0}HFMfHDrA%VrqJ{4Z%W$Fjp
zT`Ye6)JSsfj6ym~Z`l3of<3dnLplfH+JTh8GfaNARx6xPZaCbs96EliR92mWM;WTg
zxzV3U?}TSnS>~z@_9(Bj>QoV^1efUN|Ln}1sd@~FOvYgw5noIBNir3aL`M0>>z+;S
zQu&-J>4C3<nGl~%J)et+lDUJPL#`z=zK(bi=Xl~ma|<)Sue)Zvd;H64nPsi5BmU&8
zK)cjNbNOUjT3g$Z4=Lr3L{l$Nx&%vlz39ndV^5AA(>W^C$%fwVIOa#J?p%1DDE)F<
z>+CNL8HEVUDDTHFSIY`?Z{37HNjvb&=-de?EHaB}iw#Tu?HMwiI&Ro@B*nBCQWB2t
z5}O^e^%0MZU!TbItF}N2E_nGnlqm@`{VY32s!R;>UwZS&Z-}AZVAID}lz)GYa^otO
zzyl*-!3EPXP5e0bFj^rWHn;qg0<tqV(Y=4jD!^8}*n*(O?hlX~?nck+=zZ_Kg{H5L
z4vvdVYw$>fRj0?}-5TC)1%|TG)~8C$<FjV<{n*^1^#PJrzZ)T)G5>gz*>=S~eriJ?
zyWHn5NZ+)s%M}lFY2!h5Sg%^SNwZkjDZ57MHD%*w^wKSF6N5uOQU;eKgc&Y1;@UAD
zaqqtq;hE<zDj9sPuK%!{O3c5%G}D_eq+G~+*x!+!@vc!NH{z@xW9GYvRZyq|gD&ni
zP>O<C2|Use*j9yEG+rYlIHU!$EYO^V;*mC1>7iI|I!b6taCj=kmz!~n_IZb=1EQSv
zitwy$U87llkI`NB^AjmX9j~$KFu3fR<GdjLm@7sKcU`L~#_YDYlvPv%i8(XyEWqTQ
zp?68bW4gQxug;5+q6Kgc8FVAVSF+iWepo{l?@`D<TV~vTa-E%~Ry9-}0Vhoq(^u>Z
zn_Vu`kD_j;{+Q020FR9iJa;@_mvrR(tq})0j<@zBZX@eOJ%Q?&QJv*7;EUmlz${-Y
zuD?yY-@h}+^)}fu81Y9?n2*R9_QUMWgzD5ycXO;vyfI%hqeEbzVEN>~R_F13m-Mz4
zJmDtw!AG0S;ixT%lp6l%Zs@^a<+IV9f+Z-9PBW0qPL)ljWqTvu>YZOHzH@f-&T?+i
z9U(-xO%I(cxGm4q!G7Zu?5kL}xLF+96f>`MX}-#;%5cu?VQXj{V>;u<sXU60z}o4}
z>2RYDpx5{CK*y_m{$Hn5MFHP*F#cSgGXbQ*EIY$?1EPPMi%3iLV%=SzpdQ1>K{G1d
z@ZK=?%VFcGPVDdwnqVs1aZF)KYt1AuBGKI-ruVbM@wEi&0KYE6J;go|i5i>CbDJg-
zZky{DfBI$pCRx4;A1F6k6|ZA!xvu5%OiEnbAn!M4JXiRc=qOA?i`6O6@aAhGuT=Q^
zHGa_v{D=}_L#(`I<5!}-n7hcjE#mxN%~GZp^gpMlpo}9K73k?3YnIo&vjvz+I8)Up
z%{Eu-Jzjgtm)vkl@yrHrg=Mmg&Z4`?T3E&9k!uunqMgmFribVHXTX30%u*C<<AM=a
zN;}_;uGI#J*G`Dt*7xwb7ai*rc-NHA<+^J2w6LNP^AtOs$2kN9RQdMn%^6}>)=*wf
z1GJUN$P<ppyt}zqy4&+21-K)MtmWEIW0uQXf?xfhY|s2b!@8#vtuV{7kbH|i_;Cy=
z<5&es!O*u30+XsZhy)UNU=XZ=gUBFNB?_VdKGi7Jmg-9`PD@21iDY1bhJg$b$JvS0
z<|MQLN(csjr(%&rZ4f}^WT;?<3PTuBOOSNcJm^^uGBj}z0VoQ?oYhfIx5FTWf`f?Q
z8YK$S1f_>yKqg?3nk4WyLL^d?44!@q6kwsj30k22ThIo2#BZPDAS%$%{O{38doZ$Z
zMF6CXMUn`hQZo`s(f}t&oInI9K^P#(oDEHIoXp9PKo0poM{*<Y51zf<*?lxO%7OC3
z(Py^|7}CAyde8*@`!A&KA<_OJD$tj7B^<Ocpg<oB@4?Kzl>v|umPIr;bMPaMa~(-n
p;{H_I8@1gkng>c7N4DK6q=WWtw+i`xDffRtj`J?8Dbv~`e*#?kz`y_i

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/failure_signature.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/failure_signature.rs
index 7c1befbd4b3..2dae7161128 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/failure_signature.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/failure_signature.rs
@@ -5,6 +5,11 @@
 //! Advice-side members of a broken class are not enumerated: their columns and regions are named by
 //! the gadget layer and carry no stability guarantee.
 
+use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_DEGREE;
+use crate::circuits::halo2_ivc::circuit::IvcCircuit;
+use midnight_proofs::circuit::Value;
+use midnight_zk_stdlib::MidnightCircuit;
+
 use std::collections::{BTreeMap, BTreeSet};
 
 use midnight_proofs::{
@@ -136,15 +141,18 @@ pub(crate) fn assert_circuit_rejects_public_input_rows<C: Circuit<NativeField>>(
 
 /// Recursive-circuit wrapper over [`assert_circuit_rejects_public_input_rows`].
 pub(crate) fn assert_recursive_mock_prover_rejects_public_input_rows(
+    ivc_circuit: &IvcCircuit,
     ivc_circuit_data: IvcCircuitData,
     public_inputs: Vec<NativeField>,
     expected_rows: &BTreeMap<usize, &str>,
 ) {
-    assert_circuit_rejects_public_input_rows(
-        &ivc_circuit_data,
-        vec![vec![], public_inputs],
-        expected_rows,
+    let circuit = MidnightCircuit::new(
+        ivc_circuit,
+        Value::known(public_inputs.clone()),
+        Value::known(ivc_circuit_data),
+        Some(RECURSIVE_CIRCUIT_DEGREE),
     );
+    assert_circuit_rejects_public_input_rows(&circuit, vec![vec![], public_inputs], expected_rows);
 }
 
 #[cfg(test)]
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/asset_generation.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/asset_generation.rs
index 702dd826bdb..000e98cdb6b 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/asset_generation.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/asset_generation.rs
@@ -30,7 +30,7 @@ use crate::circuits::halo2_ivc::tests::common::asset_readers::{
 use crate::circuits::halo2_ivc::{
     Accumulator, AssignedAccumulator, EmulatedCurve, PREIMAGE_SIZE, RecursiveEmulation,
     accumulator::trivial_accumulator,
-    circuit::IvcCircuitData,
+    circuit::{IvcCircuit, IvcCircuitData},
     keys::RecursiveCircuitProvingKey,
     state::{Global, State},
     types::{CertificateProofBytes, IvcProofBytes},
@@ -129,17 +129,19 @@ fn build_recursive_chain_snapshot(
             INITIAL_CHAIN_LENGTH + 1
         );
         let recursive_step_start = Instant::now();
-        let ivc_circuit_data = IvcCircuitData::try_new(
+        let ivc_circuit = IvcCircuit::try_new(
+            &context.certificate_verifying_key,
+            &context.recursive_verifying_key,
+        )
+        .expect("valid IvcCircuit construction");
+        let ivc_circuit_data = IvcCircuitData::new(
             global.clone(),
             current_state.clone(),
             artifacts.recursive_witnesses[i].clone(),
             artifacts.certificate_proofs[i].clone(),
             recursive_proof.clone(),
             current_accumulator.clone(),
-            &context.certificate_verifying_key,
-            &context.recursive_verifying_key,
-        )
-        .expect("valid IvcCircuitData construction");
+        );
 
         let public_inputs = [
             global.as_public_input(),
@@ -151,6 +153,7 @@ fn build_recursive_chain_snapshot(
         let proof = prove_poseidon_ivc(
             &context.recursive_commitment_parameters,
             recursive_proving_key,
+            &ivc_circuit,
             &ivc_circuit_data,
             &public_inputs,
             &mut recursive_random_generator,
@@ -312,17 +315,19 @@ fn build_recursive_step_output_proof(
     next_step_inputs: &NextRecursiveStepInputs,
 ) -> Vec<u8> {
     let mut recursive_step_output_random_generator = OsRng;
-    let ivc_circuit_data = IvcCircuitData::try_new(
+    let ivc_circuit = IvcCircuit::try_new(
+        &context.certificate_verifying_key,
+        &context.recursive_verifying_key,
+    )
+    .expect("valid IvcCircuit construction");
+    let ivc_circuit_data = IvcCircuitData::new(
         global.clone(),
         recursive_chain_state.state.clone(),
         next_step_inputs.recursive_witness.clone(),
         next_step_inputs.certificate_proof.clone(),
         recursive_chain_state.ivc_proof.clone(),
         recursive_chain_state.accumulator.clone(),
-        &context.certificate_verifying_key,
-        &context.recursive_verifying_key,
-    )
-    .expect("valid IvcCircuitData construction");
+    );
     let public_inputs = [
         global.as_public_input(),
         next_step_inputs.next_state.as_public_input(),
@@ -335,6 +340,7 @@ fn build_recursive_step_output_proof(
     let final_proof = prove_blake2b_ivc(
         &context.recursive_commitment_parameters,
         recursive_proving_key,
+        &ivc_circuit,
         &ivc_circuit_data,
         &public_inputs,
         &mut recursive_step_output_random_generator,
@@ -541,17 +547,19 @@ pub(crate) fn generate_genesis_step_output_asset(setup: &AssetGenerationSetup, p
     let current_accumulator = trivial_accumulator(&combined_fixed_base_names);
     let next_accumulator = current_accumulator.clone();
 
-    let ivc_circuit_data = IvcCircuitData::try_new(
+    let ivc_circuit = IvcCircuit::try_new(
+        &context.certificate_verifying_key,
+        &context.recursive_verifying_key,
+    )
+    .expect("valid IvcCircuit construction");
+    let ivc_circuit_data = IvcCircuitData::new(
         global.clone(),
         State::genesis(),
         genesis_witness,
         CertificateProofBytes::empty(),
         IvcProofBytes::empty(),
         current_accumulator,
-        &context.certificate_verifying_key,
-        &context.recursive_verifying_key,
-    )
-    .expect("valid IvcCircuitData construction");
+    );
 
     let public_inputs = [
         global.as_public_input(),
@@ -566,6 +574,7 @@ pub(crate) fn generate_genesis_step_output_asset(setup: &AssetGenerationSetup, p
     let proof = prove_blake2b_ivc(
         &context.recursive_commitment_parameters,
         &recursive_proving_key,
+        &ivc_circuit,
         &ivc_circuit_data,
         &public_inputs,
         &mut rng,
@@ -692,17 +701,19 @@ pub(crate) fn generate_same_epoch_step_output_asset(
         "same-epoch next accumulator check failed"
     );
 
-    let ivc_circuit_data = IvcCircuitData::try_new(
+    let ivc_circuit = IvcCircuit::try_new(
+        &context.certificate_verifying_key,
+        &context.recursive_verifying_key,
+    )
+    .expect("valid IvcCircuit construction");
+    let ivc_circuit_data = IvcCircuitData::new(
         global.clone(),
         chain_state.state.clone(),
         ivc_witness.clone(),
         certificate_proof.clone(),
         chain_state.ivc_proof.clone(),
         chain_state.accumulator.clone(),
-        &context.certificate_verifying_key,
-        &context.recursive_verifying_key,
-    )
-    .expect("valid IvcCircuitData construction");
+    );
 
     let public_inputs = [
         global.as_public_input(),
@@ -716,6 +727,7 @@ pub(crate) fn generate_same_epoch_step_output_asset(
     let proof = prove_blake2b_ivc(
         &context.recursive_commitment_parameters,
         &recursive_proving_key,
+        &ivc_circuit,
         &ivc_circuit_data,
         &public_inputs,
         &mut rng,
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs
index 78bea6941c7..36bc2f2cad2 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs
@@ -1,3 +1,7 @@
+use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_DEGREE;
+use crate::circuits::halo2_ivc::circuit::IvcCircuit;
+use midnight_proofs::circuit::Value;
+use midnight_zk_stdlib::MidnightCircuit;
 use std::hash::Hash;
 
 use ff::FromUniformBytes;
@@ -23,6 +27,7 @@ use crate::circuits::halo2_ivc::{
 fn prove_ivc_with_transcript<H: TranscriptHash>(
     commitment_parameters: &ParamsKZG<Bls12>,
     proving_key: &RecursiveCircuitProvingKey,
+    ivc_circuit: &IvcCircuit,
     ivc_circuit_data: &IvcCircuitData,
     public_inputs: &[NativeField],
     random_generator: &mut (impl RngCore + CryptoRng),
@@ -38,11 +43,16 @@ where
         NativeField,
         KZGCommitmentScheme<PairingEngine>,
         CircuitTranscript<H>,
-        IvcCircuitData,
+        MidnightCircuit<IvcCircuit>,
     >(
         commitment_parameters,
         proving_key.proving_key(),
-        std::slice::from_ref(ivc_circuit_data),
+        std::slice::from_ref(&MidnightCircuit::new(
+            ivc_circuit,
+            Value::known(public_inputs.to_vec()),
+            Value::known(ivc_circuit_data.clone()),
+            Some(RECURSIVE_CIRCUIT_DEGREE),
+        )),
         1,
         &[&[&[], public_inputs]],
         &mut transcript,
@@ -82,6 +92,7 @@ where
 pub(crate) fn prove_poseidon_ivc(
     commitment_parameters: &ParamsKZG<Bls12>,
     proving_key: &RecursiveCircuitProvingKey,
+    ivc_circuit: &IvcCircuit,
     ivc_circuit_data: &IvcCircuitData,
     public_inputs: &[NativeField],
     random_generator: &mut (impl RngCore + CryptoRng),
@@ -89,6 +100,7 @@ pub(crate) fn prove_poseidon_ivc(
     prove_ivc_with_transcript::<PoseidonState<NativeField>>(
         commitment_parameters,
         proving_key,
+        ivc_circuit,
         ivc_circuit_data,
         public_inputs,
         random_generator,
@@ -115,6 +127,7 @@ pub(crate) fn verify_prepare_poseidon_ivc(
 pub(crate) fn prove_blake2b_ivc(
     commitment_parameters: &ParamsKZG<Bls12>,
     proving_key: &RecursiveCircuitProvingKey,
+    ivc_circuit: &IvcCircuit,
     ivc_circuit_data: &IvcCircuitData,
     public_inputs: &[NativeField],
     random_generator: &mut (impl RngCore + CryptoRng),
@@ -122,6 +135,7 @@ pub(crate) fn prove_blake2b_ivc(
     prove_ivc_with_transcript::<Blake2b256>(
         commitment_parameters,
         proving_key,
+        ivc_circuit,
         ivc_circuit_data,
         public_inputs,
         random_generator,
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs
index 160a1789601..53fbefded9e 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs
@@ -1,3 +1,4 @@
+use midnight_zk_stdlib::MidnightCircuit;
 use std::{
     collections::BTreeMap,
     io::Write,
@@ -25,7 +26,7 @@ use crate::circuits::halo2_ivc::keys::{RecursiveCircuitProvingKey, RecursiveCirc
 use crate::circuits::halo2_ivc::types::MessageHash;
 use crate::circuits::halo2_ivc::{
     CERTIFICATE_FIXED_BASES_PREFIX, EmulatedCurve, IVC_FIXED_BASES_PREFIX, NativeField,
-    PairingEngine, RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION, circuit::IvcCircuitData,
+    PairingEngine, RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION, circuit::IvcCircuit,
     state::Global,
 };
 use crate::circuits::test_utils::file_mutex::FileMutex;
@@ -216,12 +217,11 @@ fn derive_recursive_verifying_key(
     recursive_commitment_parameters: &ParamsKZG<Bls12>,
     certificate_verifying_key: &NonRecursiveCircuitVerifyingKey,
 ) -> RecursiveCircuitVerifyingKey {
-    let default_ivc_circuit =
-        IvcCircuitData::unknown(certificate_verifying_key).expect("valid IvcCircuitData unknown");
+    let default_ivc_circuit = IvcCircuit::for_key_generation(certificate_verifying_key);
     RecursiveCircuitVerifyingKey::new(
         keygen_vk_with_k(
             recursive_commitment_parameters,
-            &default_ivc_circuit,
+            &MidnightCircuit::from_relation(&default_ivc_circuit, Some(RECURSIVE_CIRCUIT_DEGREE)),
             RECURSIVE_CIRCUIT_DEGREE,
         )
         .expect("recursive verifying key generation should not fail"),
@@ -421,12 +421,11 @@ fn build_shared_recursive_context_with(
 pub(crate) fn build_recursive_proving_key(
     context: &SharedRecursiveContext,
 ) -> RecursiveCircuitProvingKey {
-    let default_ivc_circuit = IvcCircuitData::unknown(&context.certificate_verifying_key)
-        .expect("valid IvcCircuitData unknown");
+    let default_ivc_circuit = IvcCircuit::for_key_generation(&context.certificate_verifying_key);
     RecursiveCircuitProvingKey::new(
         keygen_pk(
             context.recursive_verifying_key.verifying_key().clone(),
-            &default_ivc_circuit,
+            &MidnightCircuit::from_relation(&default_ivc_circuit, Some(RECURSIVE_CIRCUIT_DEGREE)),
         )
         .expect("recursive proving key generation should not fail"),
     )
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/verification_key.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/verification_key.rs
index 12ea0e780bb..b84c43ffd0d 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/verification_key.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/verification_key.rs
@@ -12,9 +12,7 @@ use crate::{
     circuits::{
         halo2::circuit::CertificateCircuit,
         halo2::keys::NonRecursiveCircuitVerifyingKey,
-        halo2_ivc::{
-            NativeField, PairingEngine, RECURSIVE_CIRCUIT_DEGREE, circuit::IvcCircuitData,
-        },
+        halo2_ivc::{NativeField, PairingEngine, RECURSIVE_CIRCUIT_DEGREE, circuit::IvcCircuit},
     },
 };
 
@@ -41,12 +39,11 @@ pub(crate) fn golden_recursive_circuit_verification_key_bytes() -> Vec<u8> {
         midnight_zk_stdlib::setup_vk(&srs_for_non_recursive_circuit, &circuit),
     );
 
-    let default_ivc_circuit =
-        IvcCircuitData::unknown(&circuit_verification_key).expect("valid IvcCircuitData unknown");
+    let default_ivc_circuit = IvcCircuit::for_key_generation(&circuit_verification_key);
     let recursive_verifying_key: VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>> =
         keygen_vk_with_k(
             &srs_for_recursive_circuit,
-            &default_ivc_circuit,
+            &MidnightCircuit::from_relation(&default_ivc_circuit, Some(RECURSIVE_CIRCUIT_DEGREE)),
             RECURSIVE_CIRCUIT_DEGREE,
         )
         .expect("recursive verifying key generation should not fail");
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/helpers.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/helpers.rs
index 855e1ff016e..f58351e31ea 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/helpers.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/helpers.rs
@@ -1,3 +1,6 @@
+use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_DEGREE;
+use midnight_proofs::circuit::Value;
+use midnight_zk_stdlib::MidnightCircuit;
 use std::collections::BTreeMap;
 
 use midnight_circuits::types::Instantiable;
@@ -11,7 +14,7 @@ use crate::circuits::halo2_ivc::{
     Accumulator, AssignedAccumulator, EmulatedCurve, NativeField, PREIMAGE_SIZE, PairingEngine,
     RecursiveEmulation,
     accumulator::trivial_accumulator,
-    circuit::IvcCircuitData,
+    circuit::{IvcCircuit, IvcCircuitData},
     state::{Global, State, Witness},
     types::{CertificateProofBytes, IvcProofBytes, MerkleTreeCommitment, ProtocolMessagePreimage},
 };
@@ -50,6 +53,17 @@ pub(crate) struct MockProverSetup {
     pub(crate) trivial_accumulator: Accumulator<RecursiveEmulation>,
 }
 
+impl MockProverSetup {
+    /// The relation these stimuli are run against, built from the loaded verifying keys.
+    pub(crate) fn ivc_circuit(&self) -> IvcCircuit {
+        IvcCircuit::try_new(
+            &self.certificate_verifying_key,
+            &self.recursive_verifying_key,
+        )
+        .expect("valid IvcCircuit construction")
+    }
+}
+
 /// Builds the lightweight MockProver setup by loading VKs from the committed asset.
 ///
 /// Unlike `build_recursive_mock_prover_setup`, this skips SRS generation entirely
@@ -95,6 +109,17 @@ pub(crate) struct RecursiveMockProverSetup {
     pub(crate) universal_verifier_params: ParamsVerifierKZG<PairingEngine>,
 }
 
+impl RecursiveMockProverSetup {
+    /// The relation these stimuli are run against, built from the loaded verifying keys.
+    pub(crate) fn ivc_circuit(&self) -> IvcCircuit {
+        IvcCircuit::try_new(
+            &self.certificate_verifying_key,
+            &self.recursive_verifying_key,
+        )
+        .expect("valid IvcCircuit construction")
+    }
+}
+
 /// Builds the shared recursive circuit context needed by MockProver-based golden tests.
 ///
 /// This mirrors the verifier-side setup used by the asset generators, but keeps
@@ -131,11 +156,18 @@ pub(crate) fn build_recursive_mock_prover_setup(
 /// Runs `MockProver` and asserts all constraints hold, printing `label` on failure so
 /// the failing case is identifiable when multiple scenarios share one `#[test]` function.
 pub(crate) fn assert_recursive_mock_prover_accepts_with_label(
+    ivc_circuit: &IvcCircuit,
     ivc_circuit_data: IvcCircuitData,
     public_inputs: Vec<NativeField>,
     label: &str,
 ) {
-    let prover = MockProver::run(&ivc_circuit_data, vec![vec![], public_inputs])
+    let circuit = MidnightCircuit::new(
+        ivc_circuit,
+        Value::known(public_inputs.clone()),
+        Value::known(ivc_circuit_data),
+        Some(RECURSIVE_CIRCUIT_DEGREE),
+    );
+    let prover = MockProver::run(&circuit, vec![vec![], public_inputs])
         .expect("recursive MockProver setup should succeed");
     prover.verify().unwrap_or_else(|errors| {
         panic!(
@@ -304,17 +336,14 @@ fn build_asset_backed_step_fixture(
         AssignedAccumulator::as_public_input(&stored.next_accumulator),
     ]
     .concat();
-    let ivc_circuit_data = IvcCircuitData::try_new(
+    let ivc_circuit_data = IvcCircuitData::new(
         mock_prover_setup.global.clone(),
         state,
         witness,
         stored.certificate_proof,
         ivc_proof,
         accumulator,
-        &mock_prover_setup.certificate_verifying_key,
-        &mock_prover_setup.recursive_verifying_key,
-    )
-    .expect("valid IvcCircuitData construction");
+    );
 
     AssetBackedStepFixture {
         ivc_circuit_data,
@@ -374,17 +403,14 @@ pub(crate) fn build_genesis_mock_prover_circuit(
         0,
         "the trivial-accumulator stimulus is satisfiable only at genesis"
     );
-    IvcCircuitData::try_new(
+    IvcCircuitData::new(
         setup.global.clone(),
         prev_state,
         witness,
         CertificateProofBytes::empty(),
         IvcProofBytes::empty(),
         setup.trivial_accumulator.clone(),
-        &setup.certificate_verifying_key,
-        &setup.recursive_verifying_key,
     )
-    .expect("valid IvcCircuitData construction")
 }
 
 /// Builds the public-input vector for a genesis MockProver stimulus.
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/encoding/negative.rs b/mithril-stm/src/circuits/halo2_ivc/tests/encoding/negative.rs
index 4ba16224069..62163eb663c 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/encoding/negative.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/encoding/negative.rs
@@ -236,6 +236,7 @@ mod slow {
         );
 
         assert_recursive_mock_prover_rejects_public_input_rows(
+            &mock_prover_setup.ivc_circuit(),
             ivc_circuit_data,
             public_inputs,
             &BTreeMap::from([
@@ -299,6 +300,7 @@ mod slow {
         );
 
         assert_recursive_mock_prover_rejects_public_input_rows(
+            &mock_prover_setup.ivc_circuit(),
             ivc_circuit_data,
             public_inputs,
             &BTreeMap::from([(StateField::Message.row(), StateField::Message.name())]),
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/encoding/positive.rs b/mithril-stm/src/circuits/halo2_ivc/tests/encoding/positive.rs
index 50a4e92a7d5..9bec8499822 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/encoding/positive.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/encoding/positive.rs
@@ -1,6 +1,11 @@
 //! Positive encoding tests: preimage layout, state public input format, and
 //! serialization round-trips.
 
+use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_DEGREE;
+use crate::circuits::halo2_ivc::circuit::IvcCircuit;
+use crate::circuits::halo2_ivc::circuit::recursive_circuit_architecture;
+use midnight_zk_stdlib::MidnightCircuit;
+
 use ff::Field;
 use midnight_proofs::utils::SerdeFormat;
 use proptest::prelude::*;
@@ -10,7 +15,6 @@ use crate::circuits::halo2_ivc::{
     Accumulator, KZGCommitmentScheme, NativeField, PREIMAGE_CURRENT_EPOCH_BYTES,
     PREIMAGE_NEXT_MERKLE_TREE_COMMITMENT_BYTES, PREIMAGE_NEXT_PROTOCOL_PARAMETERS_BYTES,
     PREIMAGE_SIZE, PairingEngine, ProtocolMessagePreimage, RecursiveEmulation, VerifyingKey,
-    circuit::IvcCircuitData,
     io::{ReadWithFormat, WriteWithFormat},
     protocol_message::{DynamicProtocolMessagePartKey, ProtocolMessage},
     state::State,
@@ -216,8 +220,15 @@ fn vk_serialization_round_trip() {
 
     let deserialized = VerifyingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::read::<
         _,
-        IvcCircuitData,
-    >(&mut bytes.as_slice(), SerdeFormat::RawBytesUnchecked, ())
+        MidnightCircuit<IvcCircuit>,
+    >(
+        &mut bytes.as_slice(),
+        SerdeFormat::RawBytesUnchecked,
+        (
+            recursive_circuit_architecture(),
+            (RECURSIVE_CIRCUIT_DEGREE - 1) as u8,
+        ),
+    )
     .expect("verifying key deserialization should succeed");
 
     assert_eq!(
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/golden/positive.rs b/mithril-stm/src/circuits/halo2_ivc/tests/golden/positive.rs
index f8b384ec58e..bcf4bd1fe1f 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/golden/positive.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/golden/positive.rs
@@ -159,6 +159,7 @@ mod slow {
         let public_inputs =
             build_genesis_mock_prover_public_inputs(&mock_prover_setup, &next_state);
         assert_recursive_mock_prover_accepts_with_label(
+            &mock_prover_setup.ivc_circuit(),
             ivc_circuit_data,
             public_inputs,
             "genesis base case",
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/in_circuit/accumulator.rs b/mithril-stm/src/circuits/halo2_ivc/tests/in_circuit/accumulator.rs
index a86a06b5ead..01f7a2c4875 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/in_circuit/accumulator.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/in_circuit/accumulator.rs
@@ -139,17 +139,14 @@ mod slow {
             cert_accumulator,
         );
 
-        let ivc_circuit_data = IvcCircuitData::try_new(
+        let ivc_circuit_data = IvcCircuitData::new(
             mock_prover_setup.global.clone(),
             recursive_chain_state.state.clone(),
             ivc_witness,
             certificate_proof,
             recursive_chain_state.ivc_proof.clone(),
             recursive_chain_state.accumulator.clone(),
-            &mock_prover_setup.certificate_verifying_key,
-            &mock_prover_setup.recursive_verifying_key,
-        )
-        .expect("valid IvcCircuitData construction");
+        );
 
         let public_inputs = [
             mock_prover_setup.global.as_public_input(),
@@ -161,6 +158,7 @@ mod slow {
         // The signature below must not be satisfiable by a rejection that was already present.
         // Cloning keeps the certificate proved once.
         assert_recursive_mock_prover_accepts_with_label(
+            &mock_prover_setup.ivc_circuit(),
             ivc_circuit_data.clone(),
             public_inputs.clone(),
             "same-epoch step with a freshly proved certificate",
@@ -176,6 +174,7 @@ mod slow {
         }
 
         assert_recursive_mock_prover_rejects_public_input_rows(
+            &mock_prover_setup.ivc_circuit(),
             ivc_circuit_data,
             tampered_public_inputs,
             &expected_rows,
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/in_circuit/genesis_gating.rs b/mithril-stm/src/circuits/halo2_ivc/tests/in_circuit/genesis_gating.rs
index 2e858e11792..691176c8914 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/in_circuit/genesis_gating.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/in_circuit/genesis_gating.rs
@@ -39,18 +39,16 @@ mod slow {
             AssignedAccumulator::as_public_input(&mock_prover_setup.trivial_accumulator),
         ]
         .concat();
-        let ivc_circuit_data = IvcCircuitData::try_new(
+        let ivc_circuit_data = IvcCircuitData::new(
             mock_prover_setup.global.clone(),
             State::genesis(),
             build_genesis_base_case_witness(&setup),
             CertificateProofBytes::garbage(vec![0u8; 64]),
             IvcProofBytes::empty(),
             mock_prover_setup.trivial_accumulator.clone(),
-            &mock_prover_setup.certificate_verifying_key,
-            &mock_prover_setup.recursive_verifying_key,
-        )
-        .expect("valid IvcCircuitData construction");
+        );
         assert_recursive_mock_prover_accepts_with_label(
+            &mock_prover_setup.ivc_circuit(),
             ivc_circuit_data,
             public_inputs,
             "garbage certificate proof bytes (64 × 0x00)",
@@ -70,18 +68,16 @@ mod slow {
             AssignedAccumulator::as_public_input(&mock_prover_setup.trivial_accumulator),
         ]
         .concat();
-        let ivc_circuit_data = IvcCircuitData::try_new(
+        let ivc_circuit_data = IvcCircuitData::new(
             mock_prover_setup.global.clone(),
             State::genesis(),
             build_genesis_base_case_witness(&setup),
             CertificateProofBytes::empty(),
             IvcProofBytes::new(vec![0u8; 64]),
             mock_prover_setup.trivial_accumulator.clone(),
-            &mock_prover_setup.certificate_verifying_key,
-            &mock_prover_setup.recursive_verifying_key,
-        )
-        .expect("valid IvcCircuitData construction");
+        );
         assert_recursive_mock_prover_accepts_with_label(
+            &mock_prover_setup.ivc_circuit(),
             ivc_circuit_data,
             public_inputs,
             "garbage IVC proof bytes (64 × 0x00)",
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/off_circuit/circuit_validation.rs b/mithril-stm/src/circuits/halo2_ivc/tests/off_circuit/circuit_validation.rs
index a6692be0bb0..889c0f7edcd 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/off_circuit/circuit_validation.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/off_circuit/circuit_validation.rs
@@ -1,7 +1,7 @@
 //! Tests that IvcCircuitData constructor validations return the expected typed errors.
 
 use crate::circuits::halo2_ivc::{
-    RECURSIVE_CIRCUIT_DEGREE, circuit::IvcCircuitData, errors::IvcCircuitError,
+    RECURSIVE_CIRCUIT_DEGREE, circuit::IvcCircuit, errors::IvcCircuitError,
     keys::RecursiveCircuitVerifyingKey,
     tests::common::asset_readers::load_embedded_verification_context_asset,
 };
@@ -17,7 +17,7 @@ fn validate_ivc_verification_key_degree_rejects_wrong_degree_vk() {
         RecursiveCircuitVerifyingKey::new(ctx.certificate_verifying_key.midnight_vk().vk().clone());
     let actual_degree = wrong_degree_vk.verifying_key().get_domain().k();
 
-    let result = IvcCircuitData::validate_ivc_verification_key_degree(&wrong_degree_vk);
+    let result = IvcCircuit::validate_ivc_verification_key_degree(&wrong_degree_vk);
 
     let err = result
         .unwrap_err()
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/genesis.rs b/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/genesis.rs
index a33d2695b82..e5efcfd3a37 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/genesis.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/genesis.rs
@@ -124,6 +124,7 @@ mod slow {
         }
 
         assert_recursive_mock_prover_rejects_public_input_rows(
+            &mock_prover_setup.ivc_circuit(),
             ivc_circuit_data,
             public_inputs,
             &expected_rows,
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/next_epoch.rs b/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/next_epoch.rs
index 964ecaa2514..18afd9622e3 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/next_epoch.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/next_epoch.rs
@@ -105,6 +105,7 @@ mod slow {
         }
 
         assert_recursive_mock_prover_rejects_public_input_rows(
+            &mock_prover_setup.ivc_circuit(),
             fixture.ivc_circuit_data,
             fixture.public_inputs,
             &expected_rows,
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/same_epoch.rs b/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/same_epoch.rs
index 52ba3823465..85feb886591 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/same_epoch.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/transitions/negative/same_epoch.rs
@@ -105,6 +105,7 @@ mod slow {
         }
 
         assert_recursive_mock_prover_rejects_public_input_rows(
+            &mock_prover_setup.ivc_circuit(),
             fixture.ivc_circuit_data,
             fixture.public_inputs,
             &expected_rows,
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/transitions/positive.rs b/mithril-stm/src/circuits/halo2_ivc/tests/transitions/positive.rs
index 667314b24f5..bd2129d6790 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/transitions/positive.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/transitions/positive.rs
@@ -100,6 +100,7 @@ mod slow {
         let fixture = build_asset_backed_same_epoch_fixture(&mock_prover_setup);
 
         assert_recursive_mock_prover_accepts_with_label(
+            &mock_prover_setup.ivc_circuit(),
             fixture.ivc_circuit_data,
             fixture.public_inputs,
             "same-epoch step from committed assets",
@@ -114,6 +115,7 @@ mod slow {
         let fixture = build_asset_backed_next_epoch_fixture(&mock_prover_setup);
 
         assert_recursive_mock_prover_accepts_with_label(
+            &mock_prover_setup.ivc_circuit(),
             fixture.ivc_circuit_data,
             fixture.public_inputs,
             "next-epoch step from committed assets",
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/verification_key_computation.rs b/mithril-stm/src/circuits/halo2_ivc/tests/verification_key_computation.rs
index 057c7257c8d..c131dd8d6f6 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/verification_key_computation.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/verification_key_computation.rs
@@ -4,7 +4,7 @@ use midnight_proofs::{
     poly::kzg::KZGCommitmentScheme,
     utils::SerdeFormat,
 };
-use midnight_zk_stdlib::MidnightVK;
+use midnight_zk_stdlib::{MidnightCircuit, MidnightVK};
 
 use crate::{
     StmResult,
@@ -15,7 +15,7 @@ use crate::{
         },
         halo2_ivc::{
             NativeField, PairingEngine, RECURSIVE_CIRCUIT_DEGREE,
-            RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION, circuit::IvcCircuitData,
+            RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION, circuit::IvcCircuit,
         },
         trusted_setup::TrustedSetupProvider,
     },
@@ -37,12 +37,11 @@ fn compute_recursive_circuit_verification_key() -> StmResult<Vec<u8>> {
             .with_context(|| "Failed to deserialize the circuit verification key.")?,
     );
 
-    let default_ivc_circuit =
-        IvcCircuitData::unknown(&certificate_verifying_key).expect("valid IvcCircuitData unknown");
+    let default_ivc_circuit = IvcCircuit::for_key_generation(&certificate_verifying_key);
     let recursive_verification_key: VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>> =
         keygen_vk_with_k(
             &recursive_commitment_parameters,
-            &default_ivc_circuit,
+            &MidnightCircuit::from_relation(&default_ivc_circuit, Some(RECURSIVE_CIRCUIT_DEGREE)),
             shared_srs_degree,
         )?;
 
diff --git a/mithril-stm/src/circuits/halo2_ivc/witness_assignments.rs b/mithril-stm/src/circuits/halo2_ivc/witness_assignments.rs
index 2a07b5dac9a..1257257b9f6 100644
--- a/mithril-stm/src/circuits/halo2_ivc/witness_assignments.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/witness_assignments.rs
@@ -20,14 +20,10 @@ pub(crate) fn assign_global_as_public_input(
     builder: &IvcConstraintBuilder,
     layouter: &mut impl Layouter<NativeField>,
     global: &CircuitValue<Global>,
-    certificate_circuit_domain_and_constraint_system: &(
-        EvaluationDomain<NativeField>,
-        ConstraintSystem<NativeField>,
-    ),
-    ivc_circuit_domain_and_constraint_system: &(
-        EvaluationDomain<NativeField>,
-        ConstraintSystem<NativeField>,
-    ),
+    certificate_circuit_domain: &EvaluationDomain<NativeField>,
+    certificate_circuit_constraint_system: &ConstraintSystem<NativeField>,
+    ivc_circuit_domain: &EvaluationDomain<NativeField>,
+    ivc_circuit_constraint_system: &ConstraintSystem<NativeField>,
 ) -> Result<AssignedGlobal, Error> {
     let genesis_message: AssignedNative<_> = builder.native_gadget.assign_as_public_input(
         layouter,
@@ -41,8 +37,6 @@ pub(crate) fn assign_global_as_public_input(
                 .map(|gl| *gl.genesis_verification_key.as_jubjub_subgroup()),
         )?;
 
-    let (certificate_circuit_domain, certificate_circuit_constraint_system) =
-        &certificate_circuit_domain_and_constraint_system;
     let certificate_verification_key: AssignedVk<RecursiveEmulation> =
         builder.verifier_gadget.assign_vk_as_public_input(
             layouter,
@@ -55,8 +49,6 @@ pub(crate) fn assign_global_as_public_input(
         )?;
 
     // Assign for IVC proof verification
-    let (ivc_circuit_domain, ivc_circuit_constraint_system) =
-        &ivc_circuit_domain_and_constraint_system;
     let ivc_verification_key: AssignedVk<RecursiveEmulation> =
         builder.verifier_gadget.assign_vk_as_public_input(
             layouter,
diff --git a/mithril-stm/src/circuits/key_provider.rs b/mithril-stm/src/circuits/key_provider.rs
index ddab365485b..85c41877174 100644
--- a/mithril-stm/src/circuits/key_provider.rs
+++ b/mithril-stm/src/circuits/key_provider.rs
@@ -71,6 +71,32 @@ impl CircuitCacheIdentity {
     /// it changes with the circuit and only with it, which no configuration outside production can
     /// check against.
     fn for_configuration(parameters: &Parameters, merkle_tree_depth: u32) -> StmResult<Self> {
+        Self::fingerprint(parameters, merkle_tree_depth, None)
+    }
+
+    /// Identifies a configuration of the recursive circuit, additionally bound to that circuit's own
+    /// identity.
+    ///
+    /// The certificate production key alone does not stand for the recursive circuit: the recursive
+    /// circuit can change while the certificate circuit does not. A non-production entry is trusted
+    /// without comparison, so without this an entry cached for an earlier recursive circuit would be
+    /// selected and its fixed and permutation polynomials loaded against the new constraint system.
+    fn for_recursive_configuration(
+        parameters: &Parameters,
+        merkle_tree_depth: u32,
+    ) -> StmResult<Self> {
+        Self::fingerprint(
+            parameters,
+            merkle_tree_depth,
+            Some(RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION),
+        )
+    }
+
+    fn fingerprint(
+        parameters: &Parameters,
+        merkle_tree_depth: u32,
+        recursive_circuit_identity: Option<&[u8]>,
+    ) -> StmResult<Self> {
         if parameters == &STM_PARAMETERS_FOR_PRODUCTION
             && merkle_tree_depth == MERKLE_TREE_DEPTH_FOR_SNARK
         {
@@ -88,6 +114,11 @@ impl CircuitCacheIdentity {
             hasher.update((input.len() as u64).to_le_bytes());
             hasher.update(input);
         }
+        // Appended only for the recursive circuit, so certificate entries keep their identity.
+        if let Some(identity) = recursive_circuit_identity {
+            hasher.update((identity.len() as u64).to_le_bytes());
+            hasher.update(identity);
+        }
 
         Ok(Self::Fingerprinted(hex::encode(hasher.finalize())))
     }
@@ -335,7 +366,8 @@ impl KeyProvider<RecursiveCircuitKeyGenerator> {
         parameters: &Parameters,
         merkle_tree_depth: u32,
     ) -> StmResult<Self> {
-        let identity = CircuitCacheIdentity::for_configuration(parameters, merkle_tree_depth)?;
+        let identity =
+            CircuitCacheIdentity::for_recursive_configuration(parameters, merkle_tree_depth)?;
 
         Ok(Self::new(
             std::env::temp_dir(),
@@ -367,7 +399,7 @@ mod tests {
     use rand_chacha::ChaCha20Rng;
     use rand_core::SeedableRng;
 
-    use super::{CacheState, KeyGenerator, KeyProvider};
+    use super::{CacheState, CircuitCacheIdentity, KeyGenerator, KeyProvider};
     use crate::StmResult;
     use crate::circuits::halo2::{
         NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION, STM_PARAMETERS_FOR_PRODUCTION,
@@ -376,6 +408,51 @@ mod tests {
     use crate::codec::{TryFromBytes, TryToBytes};
     use crate::{MERKLE_TREE_DEPTH_FOR_SNARK, Parameters};
 
+    // The recursive and certificate circuits change independently, and a non-production entry is
+    // trusted without comparison, so the two must not share a cache directory.
+    #[test]
+    fn recursive_cache_identity_differs_from_the_certificate_one() {
+        let parameters = Parameters {
+            k: 3,
+            m: 10,
+            phi_f: 0.2,
+        };
+        let merkle_tree_depth = 4;
+
+        let certificate = CircuitCacheIdentity::for_configuration(&parameters, merkle_tree_depth)
+            .expect("certificate identity should build");
+        let recursive =
+            CircuitCacheIdentity::for_recursive_configuration(&parameters, merkle_tree_depth)
+                .expect("recursive identity should build");
+
+        assert_ne!(
+            certificate.directory_name("recursive-keys"),
+            recursive.directory_name("recursive-keys"),
+            "the recursive cache must not reuse an entry keyed only by the certificate circuit"
+        );
+    }
+
+    // Binding the recursive circuit into its own fingerprint must leave certificate entries where
+    // they were, so a recursive circuit change does not force certificate key generation.
+    #[test]
+    fn certificate_cache_identity_is_unchanged_by_the_recursive_binding() {
+        let parameters = Parameters {
+            k: 3,
+            m: 10,
+            phi_f: 0.2,
+        };
+        let merkle_tree_depth = 4;
+
+        let certificate = CircuitCacheIdentity::for_configuration(&parameters, merkle_tree_depth)
+            .expect("certificate identity should build");
+
+        assert_eq!(
+            certificate.directory_name("non-recursive-keys"),
+            "non-recursive-keys-ac5086eedf8c9015ea3b5f1b39f123e04d6105b89e17f45e731b3d80a2f91c27",
+            "certificate cache identity must not move"
+        );
+    }
+
     /// Key backed by raw bytes, so the provider mechanics can be tested without real keygen.
     #[derive(Clone, Debug, PartialEq)]
     struct ByteKey(Vec<u8>);
diff --git a/mithril-stm/src/circuits/verification_key_digest.rs b/mithril-stm/src/circuits/verification_key_digest.rs
index 088989d436d..54d8d542e86 100644
--- a/mithril-stm/src/circuits/verification_key_digest.rs
+++ b/mithril-stm/src/circuits/verification_key_digest.rs
@@ -264,7 +264,7 @@ mod tests {
                 "golden production certificate circuit verification key digest changed, either the digest computation, the embedded production key or the certificate circuit changed, which breaks published circuit verification key registries"
             );
             assert_eq!(
-                "d4c87805251f4bb7e68dde64c18d0da544cc9c2385983074fada3e753dbf6423",
+                "8a6b414e9b007a6c4ff68a349ea2a7447cb1c94cb7d3de59307197284a8db252",
                 CircuitVerificationKeyDigest::for_ivc_circuit().unwrap().to_string(),
                 "golden IVC circuit verification key digest changed, either the digest computation, the embedded production key or the IVC circuit changed, which breaks published circuit verification key registries"
             );
@@ -288,7 +288,7 @@ mod tests {
                 "golden certificate circuit verification key digest changed, either the digest computation or the circuit changed, which breaks published circuit verification key registries"
             );
             assert_eq!(
-                "d3688e5681a2a35a218006bd07f2be2ff8991a35249ac5646f9d6ba042d4ac0c",
+                "763dfd2235083e2fb78a6d35b69a8daef9331900ba61b0fea5879fd1cce7a00f",
                 recursive_key_digest.to_string(),
                 "golden IVC circuit verification key digest changed, either the digest computation or the circuit changed, which breaks published circuit verification key registries"
             );
diff --git a/mithril-stm/src/proof_system/halo2_ivc_snark/proof.rs b/mithril-stm/src/proof_system/halo2_ivc_snark/proof.rs
index 53d166f83c6..2f430a51621 100644
--- a/mithril-stm/src/proof_system/halo2_ivc_snark/proof.rs
+++ b/mithril-stm/src/proof_system/halo2_ivc_snark/proof.rs
@@ -11,6 +11,7 @@ use midnight_circuits::{
     verifier::{Accumulator, AssignedAccumulator, BlstrsEmulation},
 };
 use midnight_curves::{Bls12, G1Projective};
+use midnight_proofs::circuit::Value;
 use midnight_proofs::{
     plonk::{create_proof, prepare},
     poly::{
@@ -23,9 +24,11 @@ use midnight_proofs::{
     },
     transcript::{Blake2b256, CircuitTranscript, Hashable, Sampleable, Transcript, TranscriptHash},
 };
+use midnight_zk_stdlib::MidnightCircuit;
 use rand_core::{CryptoRng, OsRng, RngCore};
 use serde::{Deserialize, Serialize};
 
+use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_DEGREE;
 use crate::{
     AggregateVerificationKeyForSnark, AggregationError, AncillaryGenesisData, AncillaryProofInput,
     BaseFieldElement, MembershipDigest, SnarkProof, StmResult,
@@ -34,7 +37,7 @@ use crate::{
         halo2_ivc::{
             PREIMAGE_SIZE,
             accumulator::check_accumulator_fixed_bases_present,
-            circuit::IvcCircuitData,
+            circuit::{IvcCircuit, IvcCircuitData},
             keys::{RecursiveCircuitProvingKey, RecursiveCircuitVerifyingKey},
             state::{Global, State},
             types::{CertificateProofBytes, IvcProofBytes, MessageHash, ProtocolMessagePreimage},
@@ -281,20 +284,27 @@ where
     pub(crate) fn prove_with_transcript(
         srs: &ParamsKZG<Bls12>,
         proving_key: &RecursiveCircuitProvingKey,
+        ivc_circuit: &IvcCircuit,
         circuit_data: &IvcCircuitData,
         public_inputs: &[CircuitBase],
         rng: &mut (impl RngCore + CryptoRng),
     ) -> StmResult<Vec<u8>> {
+        let circuit = MidnightCircuit::new(
+            ivc_circuit,
+            Value::known(public_inputs.to_vec()),
+            Value::known(circuit_data.clone()),
+            Some(RECURSIVE_CIRCUIT_DEGREE),
+        );
         let mut transcript = CircuitTranscript::<H>::init();
         create_proof::<
             CircuitBase,
             KZGCommitmentScheme<Bls12>,
             CircuitTranscript<H>,
-            IvcCircuitData,
+            MidnightCircuit<IvcCircuit>,
         >(
             srs,
             proving_key.proving_key(),
-            std::slice::from_ref(circuit_data),
+            std::slice::from_ref(&circuit),
             1,
             &[&[&[], public_inputs]],
             &mut transcript,
@@ -434,16 +444,18 @@ impl<R: RngCore + CryptoRng> IvcProver<R> {
 
         let certificate_proof_bytes = snark_proof.into_circuit_proof_bytes();
 
-        let circuit_data = IvcCircuitData::try_new(
+        let ivc_circuit = IvcCircuit::try_new(
+            &self.ivc_setup.certificate_verifying_key,
+            &self.ivc_setup.ivc_verifying_key,
+        )?;
+        let circuit_data = IvcCircuitData::new(
             global.clone(),
             effective_rolling_state.state().clone(),
             prover_input.witness,
             certificate_proof_bytes,
             effective_rolling_state.ivc_proof().clone(),
             effective_rolling_state.accumulator().clone(),
-            &self.ivc_setup.certificate_verifying_key,
-            &self.ivc_setup.ivc_verifying_key,
-        )?;
+        );
 
         // Public inputs for the new step: [global | next_state | next_accumulator].
         let public_inputs: Vec<CircuitBase> = [
@@ -462,6 +474,7 @@ impl<R: RngCore + CryptoRng> IvcProver<R> {
             let poseidon_bytes = IvcProof::<PoseidonState<CircuitBase>>::prove_with_transcript(
                 &self.ivc_setup.srs,
                 &self.ivc_setup.ivc_proving_key,
+                &ivc_circuit,
                 &circuit_data,
                 &public_inputs,
                 &mut self.rng,
@@ -479,6 +492,7 @@ impl<R: RngCore + CryptoRng> IvcProver<R> {
         let blake2b_bytes = IvcProof::<Blake2b256>::prove_with_transcript(
             &self.ivc_setup.srs,
             &self.ivc_setup.ivc_proving_key,
+            &ivc_circuit,
             &circuit_data,
             &public_inputs,
             &mut self.rng,
@@ -514,16 +528,18 @@ impl<R: RngCore + CryptoRng> IvcProver<R> {
             global,
         )?;
 
-        let genesis_circuit_data = IvcCircuitData::try_new(
+        let genesis_ivc_circuit = IvcCircuit::try_new(
+            &self.ivc_setup.certificate_verifying_key,
+            &self.ivc_setup.ivc_verifying_key,
+        )?;
+        let genesis_circuit_data = IvcCircuitData::new(
             global.clone(),
             genesis_rolling_state.state().clone(),
             genesis_prover_input.witness,
             CertificateProofBytes::empty(),
             genesis_rolling_state.ivc_proof().clone(),
             genesis_rolling_state.accumulator().clone(),
-            &self.ivc_setup.certificate_verifying_key,
-            &self.ivc_setup.ivc_verifying_key,
-        )?;
+        );
 
         let genesis_public_inputs: Vec<CircuitBase> = [
             global.as_public_input(),
@@ -535,6 +551,7 @@ impl<R: RngCore + CryptoRng> IvcProver<R> {
         let poseidon_bytes = IvcProof::<PoseidonState<CircuitBase>>::prove_with_transcript(
             &self.ivc_setup.srs,
             &self.ivc_setup.ivc_proving_key,
+            &genesis_ivc_circuit,
             &genesis_circuit_data,
             &genesis_public_inputs,
             &mut self.rng,
@@ -1763,8 +1780,8 @@ mod tests {
         use super::*;
 
         const GOLDEN_R: [u8; 32] = [
-            167, 66, 11, 195, 134, 213, 22, 97, 36, 22, 169, 16, 222, 26, 110, 27, 81, 13, 53, 172,
-            191, 68, 90, 117, 248, 154, 30, 122, 198, 17, 214, 30,
+            236, 82, 235, 208, 194, 213, 21, 52, 158, 242, 42, 124, 219, 198, 65, 232, 86, 191, 84,
+            104, 0, 39, 228, 81, 172, 96, 198, 123, 29, 236, 243, 50,
         ];
 
         #[test]
diff --git a/mithril-stm/src/protocol/aggregate_signature/ancillary_data.rs b/mithril-stm/src/protocol/aggregate_signature/ancillary_data.rs
index 5b8ce826f1c..b7cf8b21f4f 100644
--- a/mithril-stm/src/protocol/aggregate_signature/ancillary_data.rs
+++ b/mithril-stm/src/protocol/aggregate_signature/ancillary_data.rs
@@ -491,15 +491,16 @@ mod tests {
     /// hardcoded digest, so appending the `Snark` variant to `AncillaryVerifierData` cannot
     /// silently change the encoding of the existing variant — which would break committed IVC
     /// certificates. ciborium tags enum variants by name, so the encoding is independent of variant
-    /// order; the digest below is the pre-change value and must never change.
+    /// order. The digest pins the complete encoded bytes, embedded verifying keys included, so it
+    /// legitimately moves whenever a circuit changes and must be recomputed with those keys.
     #[cfg(feature = "future_snark")]
     #[test]
     fn ivc_ancillary_encoding_is_byte_stable() {
         use sha2::{Digest, Sha256};
 
         const EXPECTED_IVC_ANCILLARY_DIGEST: [u8; 32] = [
-            98, 51, 110, 52, 61, 7, 186, 33, 25, 69, 151, 75, 36, 223, 4, 98, 6, 240, 88, 93, 35,
-            185, 12, 157, 96, 39, 6, 65, 20, 46, 13, 146,
+            166, 23, 43, 148, 143, 254, 123, 150, 165, 210, 35, 250, 36, 248, 222, 137, 180, 56,
+            75, 253, 228, 42, 64, 179, 144, 17, 68, 254, 99, 93, 223, 242,
         ];
         let context = load_embedded_verification_context_asset()
             .expect("verification context asset should load");

From 9a2bc1a27ed316e9e06e9dd4cfac6e4003b7868b Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Wed, 16 Sep 2026 14:15:39 +0900
Subject: [PATCH 04/14] refactor(stm): encode the recursive circuit keys in the
 Midnight format

Both circuits now serialize their keys in the same format, so a single codec
serves them. The inner verifying key is unchanged, so the circuit identity, the
digests and the existing proofs are untouched; the keys only gain a 23 byte
self-describing envelope.

Because the two formats are now identical, the recursive decoders validate the
declared architecture and every declared degree before the bytes reach the
dependency's readers, so a key belonging to another circuit is rejected.
---
 .../src/circuits/halo2_ivc/embedded_assets.rs |  19 +-
 mithril-stm/src/circuits/halo2_ivc/errors.rs  |  14 +
 .../circuits/halo2_ivc/key_serialization.rs   |  99 ----
 mithril-stm/src/circuits/halo2_ivc/keys.rs    | 511 +++++++++++++++---
 mithril-stm/src/circuits/halo2_ivc/mod.rs     |   4 +-
 ...ircuit_verification_key_for_production.bin | Bin 6054 -> 6077 bytes
 ...den_recursive_circuit_verification_key.bin | Bin 6054 -> 6077 bytes
 .../tests/assets/verification_context.bin     | Bin 21142 -> 21165 bytes
 .../halo2_ivc/tests/common/asset_readers.rs   |   2 +-
 .../tests/common/generators/proofs.rs         |   2 +-
 .../tests/common/generators/setup.rs          |  30 +-
 .../common/generators/verification_key.rs     |  18 +-
 .../tests/off_circuit/circuit_validation.rs   |   2 +-
 .../tests/verification_key_computation.rs     |  20 +-
 mithril-stm/src/circuits/trusted_setup.rs     |   2 +
 .../src/proof_system/halo2_ivc_snark/proof.rs |   2 +-
 .../halo2_ivc_snark/verifier_setup.rs         |  48 ++
 .../aggregate_signature/ancillary_data.rs     |   4 +-
 18 files changed, 544 insertions(+), 233 deletions(-)
 delete mode 100644 mithril-stm/src/circuits/halo2_ivc/key_serialization.rs

diff --git a/mithril-stm/src/circuits/halo2_ivc/embedded_assets.rs b/mithril-stm/src/circuits/halo2_ivc/embedded_assets.rs
index 77cd4474991..ce8ff29626d 100644
--- a/mithril-stm/src/circuits/halo2_ivc/embedded_assets.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/embedded_assets.rs
@@ -19,15 +19,13 @@ use midnight_proofs::{
     poly::kzg::params::ParamsVerifierKZG,
     utils::{SerdeFormat, helpers::ProcessedSerdeObject},
 };
-use midnight_zk_stdlib::{MidnightCircuit, MidnightVK};
+use midnight_zk_stdlib::MidnightVK;
 
 use crate::StmResult;
 use crate::circuits::halo2::keys::NonRecursiveCircuitVerifyingKey;
 use crate::circuits::halo2_ivc::keys::RecursiveCircuitVerifyingKey;
 use crate::circuits::halo2_ivc::{
-    Accumulator, EmulatedCurve, KZGCommitmentScheme, NativeField, PREIMAGE_SIZE, PairingEngine,
-    RECURSIVE_CIRCUIT_DEGREE, RecursiveEmulation, VerifyingKey,
-    circuit::{IvcCircuit, recursive_circuit_architecture},
+    Accumulator, EmulatedCurve, NativeField, PREIMAGE_SIZE, PairingEngine, RecursiveEmulation,
     io::ReadWithFormat,
     state::State,
     types::{
@@ -351,18 +349,7 @@ fn load_verification_context_asset_from_reader<R: Read>(
     let global_field_elements = (0..5)
         .map(|_| read_field_element(reader))
         .collect::<Result<Vec<_>, _>>()?;
-    let recursive_verifying_key =
-        VerifyingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::read::<
-            _,
-            MidnightCircuit<IvcCircuit>,
-        >(
-            reader,
-            SerdeFormat::RawBytesUnchecked,
-            (
-                recursive_circuit_architecture(),
-                (RECURSIVE_CIRCUIT_DEGREE - 1) as u8,
-            ),
-        )?;
+    let recursive_verifying_key = MidnightVK::read(reader, SerdeFormat::RawBytesUnchecked)?;
     let combined_fixed_bases = read_named_fixed_bases(reader)?;
 
     // verifier_params is length-prefixed so the certificate verification key can follow it.
diff --git a/mithril-stm/src/circuits/halo2_ivc/errors.rs b/mithril-stm/src/circuits/halo2_ivc/errors.rs
index c0a0131fd53..1ebbdc62ca9 100644
--- a/mithril-stm/src/circuits/halo2_ivc/errors.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/errors.rs
@@ -22,6 +22,20 @@ pub enum IvcCircuitError {
     #[error("Byte-to-field conversion received {bytes} bytes but only {bases} base weights")]
     ByteCountExceedsBaseCount { bytes: usize, bases: usize },
 
+    /// A recursive verifying key was encoded for a different standard library architecture, so it
+    /// belongs to another circuit.
+    #[error("The recursive verifying key declares an architecture that is not the IVC circuit's")]
+    RecursiveVerificationKeyArchitectureMismatch,
+
+    /// A recursive verifying key carried a different number of fixed commitments than the
+    /// configured constraint system has columns.
+    #[error("The recursive verifying key declares {actual} fixed commitments, expected {expected}")]
+    RecursiveVerificationKeyCommitmentCountMismatch { expected: usize, actual: usize },
+
+    /// A standalone recursive key encoding carried bytes beyond the key.
+    #[error("The recursive key encoding carries {trailing} trailing bytes")]
+    RecursiveKeyEncodingHasTrailingBytes { trailing: usize },
+
     /// Off-circuit step transition: the incoming certificate's epoch does not advance the
     /// chain correctly. The `kind` field carries an `EpochTransitionErrorKind` with the
     /// specific violation.
diff --git a/mithril-stm/src/circuits/halo2_ivc/key_serialization.rs b/mithril-stm/src/circuits/halo2_ivc/key_serialization.rs
deleted file mode 100644
index 179928cfe0f..00000000000
--- a/mithril-stm/src/circuits/halo2_ivc/key_serialization.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-//! [`TryToBytes`] / [`TryFromBytes`] impls for the recursive circuit's raw PLONK keys.
-//!
-//! The raw PLONK `read` is generic over the circuit type and takes its `Params`, so these impls pin
-//! the standard library's wrapper around [`IvcCircuit`] and its architecture and range parameters,
-//! rebuilding the constraint system key generation used.
-//!
-//! Note: only the IVC circuit's keys are ever deserialized raw here; the certificate keys round-trip
-//! as the high-level `MidnightVK` / `MidnightPK`.
-
-use crate::StmResult;
-use crate::circuits::key_serialization::KEY_SERDE_FORMAT;
-use crate::codec::{TryFromBytes, TryToBytes};
-use anyhow::Context;
-
-use midnight_zk_stdlib::MidnightCircuit;
-
-use super::{
-    KZGCommitmentScheme, NativeField, PairingEngine, ProvingKey, RECURSIVE_CIRCUIT_DEGREE,
-    VerifyingKey,
-    circuit::{IvcCircuit, recursive_circuit_architecture},
-};
-
-// Recursive (IVC) circuit verifying key. The raw PLONK `read` is generic over the circuit and
-// takes its `Params`, so it is pinned below to the standard library's wrapper around `IvcCircuit`,
-// with the architecture and range parameters that rebuild the same constraint system.
-impl TryToBytes for VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>> {
-    fn to_bytes_vec(&self) -> StmResult<Vec<u8>> {
-        let mut bytes = Vec::new();
-        self.write(&mut bytes, KEY_SERDE_FORMAT)
-            .with_context(|| "Failed to serialize the recursive PLONK verifying key")?;
-        Ok(bytes)
-    }
-}
-
-impl TryFromBytes for VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>> {
-    fn try_from_bytes(bytes: &[u8]) -> StmResult<Self> {
-        let mut reader = bytes;
-        VerifyingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::read::<
-            _,
-            MidnightCircuit<IvcCircuit>,
-        >(
-            &mut reader,
-            KEY_SERDE_FORMAT,
-            (
-                recursive_circuit_architecture(),
-                (RECURSIVE_CIRCUIT_DEGREE - 1) as u8,
-            ),
-        )
-        .with_context(|| "Failed to deserialize the recursive PLONK verifying key")
-    }
-}
-
-// Recursive (IVC) circuit proving key.
-impl TryToBytes for ProvingKey<NativeField, KZGCommitmentScheme<PairingEngine>> {
-    fn to_bytes_vec(&self) -> StmResult<Vec<u8>> {
-        let mut bytes = Vec::new();
-        self.write(&mut bytes, KEY_SERDE_FORMAT)
-            .with_context(|| "Failed to serialize the recursive PLONK proving key")?;
-        Ok(bytes)
-    }
-}
-
-impl TryFromBytes for ProvingKey<NativeField, KZGCommitmentScheme<PairingEngine>> {
-    fn try_from_bytes(bytes: &[u8]) -> StmResult<Self> {
-        let mut reader = bytes;
-        ProvingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::read::<
-            _,
-            MidnightCircuit<IvcCircuit>,
-        >(
-            &mut reader,
-            KEY_SERDE_FORMAT,
-            (
-                recursive_circuit_architecture(),
-                (RECURSIVE_CIRCUIT_DEGREE - 1) as u8,
-            ),
-        )
-        .with_context(|| "Failed to deserialize the recursive PLONK proving key")
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
-
-    #[test]
-    fn production_verifying_key_serializes_to_the_embedded_bytes() {
-        let verifying_key =
-            VerifyingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::try_from_bytes(
-                RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
-            )
-            .expect("production recursive verifying key bytes should deserialize");
-        assert_eq!(
-            verifying_key.to_bytes_vec().expect("serialize should succeed"),
-            RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
-            "the embedded production recursive verifying key must be its own canonical serialization"
-        );
-    }
-}
diff --git a/mithril-stm/src/circuits/halo2_ivc/keys.rs b/mithril-stm/src/circuits/halo2_ivc/keys.rs
index 3a694092886..8c49b1920d4 100644
--- a/mithril-stm/src/circuits/halo2_ivc/keys.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/keys.rs
@@ -1,12 +1,14 @@
 // Per-circuit key newtypes for the recursive (IVC) circuit, and the circuit's implementation of
-// [`KeyGenerator`]. The newtypes wrap the raw PLONK keys and delegate their byte
-// (de)serialization to the impls in `key_serialization`; the raw keys stay internal to
-// `circuits::halo2_ivc`, where Halo2's keygen APIs require them.
+// [`KeyGenerator`]. The newtypes wrap Midnight's self-describing `MidnightVK` / `MidnightPK`, the
+// same format the certificate circuit's keys use; the raw verifying key stays reachable for the
+// accumulator and verifier code that needs it.
+use std::io::Read;
+
+use anyhow::{Context, anyhow};
 use midnight_curves::Bls12;
-use midnight_proofs::plonk::{keygen_pk, keygen_vk_with_k};
 use midnight_proofs::poly::commitment::Params;
 use midnight_proofs::poly::kzg::params::ParamsKZG;
-use midnight_zk_stdlib::MidnightCircuit;
+use midnight_zk_stdlib::{self as zk, MidnightPK, MidnightVK};
 use serde::{Deserialize, Serialize};
 
 use crate::StmResult;
@@ -14,38 +16,43 @@ use crate::circuits::halo2::circuit::CertificateCircuit;
 use crate::circuits::halo2::keys::NonRecursiveCircuitVerifyingKey;
 use crate::circuits::key_generator::KeyGenerator;
 use crate::circuits::key_provider::KeyProvider;
+use crate::circuits::key_serialization::KEY_SERDE_FORMAT;
+use crate::circuits::trusted_setup::MIDNIGHT_SRS_DEGREE;
 use crate::codec::{TryFromBytes, TryToBytes};
 
 use super::{
-    KZGCommitmentScheme, NativeField, PairingEngine, ProvingKey, RECURSIVE_CIRCUIT_DEGREE,
-    VerifyingKey, circuit::IvcCircuit,
+    ConstraintSystem, KZGCommitmentScheme, NativeField, PairingEngine, RECURSIVE_CIRCUIT_DEGREE,
+    VerifyingKey, ZkStdLib, ZkStdLibArch,
+    circuit::{IvcCircuit, recursive_circuit_architecture},
+    errors::IvcCircuitError,
 };
 
 /// Verifying key of the recursive (IVC) circuit.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub(crate) struct RecursiveCircuitVerifyingKey(
-    #[serde(with = "recursive_verifying_key_serde")]
-    VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>>,
+    #[serde(with = "recursive_verifying_key_serde")] MidnightVK,
 );
 
 /// Proving key of the recursive (IVC) circuit.
-pub(crate) struct RecursiveCircuitProvingKey(
-    ProvingKey<NativeField, KZGCommitmentScheme<PairingEngine>>,
-);
+#[derive(Clone)]
+pub(crate) struct RecursiveCircuitProvingKey(MidnightPK<IvcCircuit>);
 
 impl RecursiveCircuitVerifyingKey {
-    /// Wraps a raw recursive verifying key.
-    pub(crate) fn new(
-        verifying_key: VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>>,
-    ) -> Self {
-        Self(verifying_key)
+    /// Wraps a Midnight verifying key.
+    pub(crate) fn new(midnight_vk: MidnightVK) -> Self {
+        Self(midnight_vk)
+    }
+
+    /// Borrows the wrapped Midnight verifying key.
+    pub(crate) fn midnight_vk(&self) -> &MidnightVK {
+        &self.0
     }
 
-    /// Borrows the wrapped raw verifying key, for the prover/verifier and fixed-base construction.
+    /// Borrows the raw verifying key, for the prover/verifier and fixed-base construction.
     pub(crate) fn verifying_key(
         &self,
     ) -> &VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>> {
-        &self.0
+        self.0.vk()
     }
 
     #[cfg(test)]
@@ -53,32 +60,159 @@ impl RecursiveCircuitVerifyingKey {
     pub(crate) fn circuit_degree(&self) -> u32 {
         self.as_ref().get_domain().k()
     }
+
+    /// Rejects a declared degree that is not the recursive circuit's.
+    ///
+    /// Both readers derive a range bit length from their degree as `k - 1` on a byte, which
+    /// underflows for a zero degree, and a large degree reaches a domain constructor that asserts.
+    /// So every declared degree is checked before the bytes reach the dependency.
+    fn validate_declared_degree(degree: u8) -> StmResult<()> {
+        if u32::from(degree) != RECURSIVE_CIRCUIT_DEGREE {
+            return Err(anyhow!(IvcCircuitError::IvcVerificationKeyDegreeMismatch {
+                expected: RECURSIVE_CIRCUIT_DEGREE,
+                actual: u32::from(degree),
+            }));
+        }
+        Ok(())
+    }
+
+    /// Number of fixed commitments the approved architecture produces.
+    ///
+    /// The reader takes this count from the bytes and reads that many commitments, so a key can
+    /// declare fewer than the configured constraint system has columns; later verification indexes
+    /// commitments by those columns.
+    fn expected_fixed_commitment_count() -> usize {
+        let mut constraint_system = ConstraintSystem::<NativeField>::default();
+        ZkStdLib::configure(
+            &mut constraint_system,
+            (
+                recursive_circuit_architecture(),
+                (RECURSIVE_CIRCUIT_DEGREE - 1) as u8,
+            ),
+        );
+        // Selectors become fixed columns when the key is read.
+        constraint_system.num_fixed_columns() + constraint_system.num_selectors()
+    }
+
+    /// Checks every degree an encoded recursive proving key declares, before it is decoded.
+    ///
+    /// The reader takes four in turn without validating any: its own, the two the relation's
+    /// certificate key declares, and the one inside the wrapped raw recursive key. Each reaches a
+    /// `k - 1` subtraction on a byte or a domain constructor that asserts, so all four are checked
+    /// here.
+    fn validate_encoded_proving_key_header(bytes: &[u8]) -> StmResult<()> {
+        let mut reader = bytes;
+
+        let mut proving_key_degree = [0u8; 1];
+        reader
+            .read_exact(&mut proving_key_degree)
+            .with_context(|| "Failed to read the recursive proving key degree")?;
+        Self::validate_declared_degree(proving_key_degree[0])?;
+
+        // The relation carries the certificate key it was generated against, length prefixed.
+        let mut certificate_key_length = [0u8; 4];
+        reader
+            .read_exact(&mut certificate_key_length)
+            .with_context(|| "Failed to read the relation's certificate key length")?;
+        let certificate_key_length = u32::from_le_bytes(certificate_key_length) as usize;
+        let certificate_key = reader
+            .get(..certificate_key_length)
+            .ok_or_else(|| anyhow!("The relation's certificate key is truncated"))?;
+        validate_certificate_key_declared_degrees(certificate_key)?;
+        reader = &reader[certificate_key_length..];
+
+        // The wrapped raw recursive key opens with its own version and degree.
+        let mut raw_header = [0u8; 2];
+        reader
+            .read_exact(&mut raw_header)
+            .with_context(|| "Failed to read the wrapped raw proving key header")?;
+        Self::validate_declared_degree(raw_header[1])
+    }
+
+    /// Checks the header of an encoded recursive verifying key before it is decoded.
+    ///
+    /// `MidnightVK` takes its architecture and degree from the bytes, so without this any Midnight
+    /// circuit's key would decode in the recursive position. Both degrees are checked: the envelope
+    /// declares one and the raw key it wraps declares another, and the reader takes them
+    /// independently without comparing them, so an envelope claiming the expected degree can carry
+    /// a raw key of a different one.
+    fn validate_encoded_header(bytes: &[u8]) -> StmResult<()> {
+        let mut reader = bytes;
+        let architecture = ZkStdLibArch::read_from_serialized_vk(&mut reader)
+            .with_context(|| "Failed to read the recursive verifying key architecture")?;
+        if architecture != recursive_circuit_architecture() {
+            return Err(anyhow!(
+                IvcCircuitError::RecursiveVerificationKeyArchitectureMismatch
+            ));
+        }
+
+        let mut envelope_degree = [0u8; 1];
+        reader
+            .read_exact(&mut envelope_degree)
+            .with_context(|| "Failed to read the recursive verifying key degree")?;
+        Self::validate_declared_degree(envelope_degree[0])?;
+
+        let mut public_input_count = [0u8; 4];
+        reader
+            .read_exact(&mut public_input_count)
+            .with_context(|| "Failed to read the recursive verifying key public input count")?;
+
+        // The wrapped raw key opens with its own version and degree.
+        let mut raw_header = [0u8; 2];
+        reader
+            .read_exact(&mut raw_header)
+            .with_context(|| "Failed to read the wrapped raw verifying key header")?;
+        Self::validate_declared_degree(raw_header[1])
+    }
 }
 
 impl AsRef<VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>>>
     for RecursiveCircuitVerifyingKey
 {
     fn as_ref(&self) -> &VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>> {
-        &self.0
+        self.0.vk()
     }
 }
 
 impl RecursiveCircuitProvingKey {
-    /// Wraps a raw recursive proving key.
-    pub(crate) fn new(
-        proving_key: ProvingKey<NativeField, KZGCommitmentScheme<PairingEngine>>,
-    ) -> Self {
-        Self(proving_key)
+    /// Wraps a Midnight proving key.
+    pub(crate) fn new(midnight_pk: MidnightPK<IvcCircuit>) -> Self {
+        Self(midnight_pk)
     }
 
-    /// Borrows the wrapped raw proving key, for proof generation.
-    pub(crate) fn proving_key(
-        &self,
-    ) -> &ProvingKey<NativeField, KZGCommitmentScheme<PairingEngine>> {
+    /// Borrows the wrapped Midnight proving key, for proof generation.
+    pub(crate) fn midnight_pk(&self) -> &MidnightPK<IvcCircuit> {
         &self.0
     }
 }
 
+/// Serde for the wrapped Midnight verifying key, routed through the newtype's guarded byte decoder
+/// so the verifier-data envelopes cannot reach the dependency's readers unchecked.
+mod recursive_verifying_key_serde {
+    use midnight_zk_stdlib::MidnightVK;
+    use serde::{Deserializer, Serializer};
+
+    use super::RecursiveCircuitVerifyingKey;
+    use crate::codec::{TryFromBytes, TryToBytes};
+
+    pub(super) fn serialize<S: Serializer>(
+        verifying_key: &MidnightVK,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let bytes = verifying_key.to_bytes_vec().map_err(serde::ser::Error::custom)?;
+        serializer.serialize_bytes(&bytes)
+    }
+
+    pub(super) fn deserialize<'de, D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<MidnightVK, D::Error> {
+        let bytes: Vec<u8> = serde::Deserialize::deserialize(deserializer)?;
+        RecursiveCircuitVerifyingKey::try_from_bytes(&bytes)
+            .map(|key| key.0)
+            .map_err(serde::de::Error::custom)
+    }
+}
+
 impl TryToBytes for RecursiveCircuitVerifyingKey {
     fn to_bytes_vec(&self) -> StmResult<Vec<u8>> {
         self.0.to_bytes_vec()
@@ -87,51 +221,104 @@ impl TryToBytes for RecursiveCircuitVerifyingKey {
 
 impl TryFromBytes for RecursiveCircuitVerifyingKey {
     fn try_from_bytes(bytes: &[u8]) -> StmResult<Self> {
-        Ok(Self(VerifyingKey::<
-            NativeField,
-            KZGCommitmentScheme<PairingEngine>,
-        >::try_from_bytes(bytes)?))
+        Self::validate_encoded_header(bytes)?;
+
+        let mut reader = bytes;
+        let midnight_vk = MidnightVK::read(&mut reader, KEY_SERDE_FORMAT)
+            .with_context(|| "Failed to deserialize the recursive verifying key")?;
+        // A standalone encoding holds one key and nothing else; the streaming asset reader, where a
+        // fixed-base map follows the key, deliberately does not go through here.
+        if !reader.is_empty() {
+            return Err(anyhow!(
+                IvcCircuitError::RecursiveKeyEncodingHasTrailingBytes {
+                    trailing: reader.len(),
+                }
+            ));
+        }
+
+        let actual = midnight_vk.vk().fixed_commitments().len();
+        let expected = Self::expected_fixed_commitment_count();
+        if actual != expected {
+            return Err(anyhow!(
+                IvcCircuitError::RecursiveVerificationKeyCommitmentCountMismatch {
+                    expected,
+                    actual
+                }
+            ));
+        }
+
+        Ok(Self(midnight_vk))
     }
 }
 
 impl TryToBytes for RecursiveCircuitProvingKey {
     fn to_bytes_vec(&self) -> StmResult<Vec<u8>> {
-        self.0.to_bytes_vec()
+        let mut bytes = Vec::new();
+        self.0
+            .write(&mut bytes, KEY_SERDE_FORMAT)
+            .with_context(|| "Failed to serialize the recursive proving key")?;
+        Ok(bytes)
     }
 }
 
 impl TryFromBytes for RecursiveCircuitProvingKey {
     fn try_from_bytes(bytes: &[u8]) -> StmResult<Self> {
-        Ok(Self(ProvingKey::<
-            NativeField,
-            KZGCommitmentScheme<PairingEngine>,
-        >::try_from_bytes(bytes)?))
+        RecursiveCircuitVerifyingKey::validate_encoded_proving_key_header(bytes)?;
+
+        let mut reader = bytes;
+        Ok(Self(
+            MidnightPK::<IvcCircuit>::read(&mut reader, KEY_SERDE_FORMAT)
+                .with_context(|| "Failed to deserialize the recursive proving key")?,
+        ))
     }
 }
 
-/// Serde for the wrapped raw recursive verifying key: the raw-bytes encoding pinned to the IVC
-/// circuit (via the key's byte codec), matching the embedded verifier-data wire format.
-mod recursive_verifying_key_serde {
-    use serde::{Deserializer, Serializer};
+/// Rejects a certificate key whose declared degrees could not belong to any supported certificate
+/// circuit.
+///
+/// A certificate key is generated from the trusted setup, so it cannot exceed that setup's degree.
+///
+/// Certificate degrees legitimately vary — production, the full fixture and the small golden context
+/// all differ — so these are bounded rather than pinned. The key declares a degree twice, once in
+/// its Midnight envelope and once in the raw key it wraps, and the reader takes them independently:
+/// an envelope declaring a supported degree can wrap a raw key declaring any other, which reaches a
+/// domain constructor that asserts.
+fn validate_certificate_key_declared_degrees(certificate_key: &[u8]) -> StmResult<()> {
+    let mut reader = certificate_key;
+    ZkStdLibArch::read_from_serialized_vk(&mut reader)
+        .with_context(|| "Failed to read the certificate key architecture")?;
 
-    use super::{KZGCommitmentScheme, NativeField, PairingEngine, VerifyingKey};
-    use crate::codec::{TryFromBytes, TryToBytes};
+    let mut envelope_degree = [0u8; 1];
+    reader
+        .read_exact(&mut envelope_degree)
+        .with_context(|| "Failed to read the certificate key envelope degree")?;
 
-    pub(super) fn serialize<S: Serializer>(
-        verifying_key: &VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>>,
-        serializer: S,
-    ) -> Result<S::Ok, S::Error> {
-        let bytes = verifying_key.to_bytes_vec().map_err(serde::ser::Error::custom)?;
-        serializer.serialize_bytes(&bytes)
-    }
+    let mut public_input_count = [0u8; 4];
+    reader
+        .read_exact(&mut public_input_count)
+        .with_context(|| "Failed to read the certificate key public input count")?;
 
-    pub(super) fn deserialize<'de, D: Deserializer<'de>>(
-        deserializer: D,
-    ) -> Result<VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>>, D::Error> {
-        let bytes: Vec<u8> = serde::Deserialize::deserialize(deserializer)?;
-        VerifyingKey::<NativeField, KZGCommitmentScheme<PairingEngine>>::try_from_bytes(&bytes)
-            .map_err(serde::de::Error::custom)
+    // The wrapped raw key opens with its own version and degree.
+    let mut raw_header = [0u8; 2];
+    reader
+        .read_exact(&mut raw_header)
+        .with_context(|| "Failed to read the wrapped raw certificate key header")?;
+
+    for degree in [envelope_degree[0], raw_header[1]] {
+        if degree == 0 || degree > MIDNIGHT_SRS_DEGREE {
+            return Err(anyhow!(IvcCircuitError::IvcVerificationKeyDegreeMismatch {
+                expected: u32::from(MIDNIGHT_SRS_DEGREE),
+                actual: u32::from(degree),
+            }));
+        }
+    }
+    if envelope_degree[0] != raw_header[1] {
+        return Err(anyhow!(IvcCircuitError::IvcVerificationKeyDegreeMismatch {
+            expected: u32::from(envelope_degree[0]),
+            actual: u32::from(raw_header[1]),
+        }));
     }
+    Ok(())
 }
 
 impl KeyGenerator for IvcCircuit {
@@ -150,15 +337,15 @@ impl KeyGenerator for IvcCircuit {
             srs.max_k() >= RECURSIVE_CIRCUIT_DEGREE,
             "the SRS must be at least the recursive circuit degree"
         );
-        let circuit = MidnightCircuit::from_relation(self, Some(RECURSIVE_CIRCUIT_DEGREE));
+        // `setup_vk` takes the degree from the SRS, so it must be exactly the circuit's.
         let verifying_key = if srs.max_k() == RECURSIVE_CIRCUIT_DEGREE {
-            keygen_vk_with_k(srs, &circuit, RECURSIVE_CIRCUIT_DEGREE)?
+            zk::setup_vk(srs, self)
         } else {
             let mut recursive_srs = srs.clone();
             recursive_srs.downsize(RECURSIVE_CIRCUIT_DEGREE);
-            keygen_vk_with_k(&recursive_srs, &circuit, RECURSIVE_CIRCUIT_DEGREE)?
+            zk::setup_vk(&recursive_srs, self)
         };
-        let proving_key = keygen_pk(verifying_key.clone(), &circuit)?;
+        let proving_key = zk::setup_pk(self, &verifying_key);
         Ok((
             RecursiveCircuitVerifyingKey(verifying_key),
             RecursiveCircuitProvingKey(proving_key),
@@ -209,6 +396,7 @@ impl KeyGenerator for RecursiveCircuitKeyGenerator {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::circuits::halo2::NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
     use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
 
     #[test]
@@ -223,4 +411,205 @@ mod tests {
             "the recursive verifying key newtype must round-trip to the embedded production bytes"
         );
     }
+
+    // Both circuits now encode their keys the same way, so only the declared architecture separates
+    // them: without the header check the certificate's key would decode in the recursive position.
+    #[test]
+    fn a_certificate_verifying_key_is_rejected_in_the_recursive_position() {
+        let error = RecursiveCircuitVerifyingKey::try_from_bytes(
+            NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
+        )
+        .expect_err("a certificate key must not decode as a recursive one");
+
+        assert!(
+            matches!(
+                error.downcast_ref::<IvcCircuitError>(),
+                Some(IvcCircuitError::RecursiveVerificationKeyArchitectureMismatch)
+            ),
+            "expected an architecture mismatch, got: {error}"
+        );
+    }
+
+    // `MidnightVK::read` derives its range bit length as `k - 1` on a byte, so a zero degree would
+    // underflow inside the dependency before any check of ours could run.
+    #[test]
+    fn a_zero_degree_header_is_rejected_before_it_can_underflow() {
+        let mut bytes = RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec();
+        // The degree byte follows the encoded architecture.
+        let mut reader = RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+        ZkStdLibArch::read_from_serialized_vk(&mut reader).expect("architecture should read");
+        let degree_index = bytes.len() - reader.len();
+        bytes[degree_index] = 0;
+
+        let error = RecursiveCircuitVerifyingKey::try_from_bytes(&bytes)
+            .expect_err("a zero degree must be rejected");
+
+        assert!(
+            matches!(
+                error.downcast_ref::<IvcCircuitError>(),
+                Some(IvcCircuitError::IvcVerificationKeyDegreeMismatch { actual: 0, .. })
+            ),
+            "expected a degree mismatch, got: {error}"
+        );
+    }
+
+    // The envelope and the raw key it wraps each declare a degree, and the reader takes them
+    // independently, so an envelope claiming the right one can still carry a raw key of another.
+    #[test]
+    fn a_wrapped_raw_key_of_the_wrong_degree_is_rejected() {
+        let mut bytes = RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec();
+        // Past the architecture, the envelope degree and the public input count lies the raw
+        // key's own version byte, and its degree follows.
+        let mut reader = RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+        ZkStdLibArch::read_from_serialized_vk(&mut reader).expect("architecture should read");
+        let raw_degree_index = bytes.len() - reader.len() + 1 + 4 + 1;
+        assert_eq!(
+            u32::from(bytes[raw_degree_index]),
+            RECURSIVE_CIRCUIT_DEGREE,
+            "the wrapped raw key should declare the recursive degree before it is mutated"
+        );
+        bytes[raw_degree_index] = 20;
+
+        let error = RecursiveCircuitVerifyingKey::try_from_bytes(&bytes)
+            .expect_err("a wrapped key of another degree must be rejected");
+
+        assert!(
+            matches!(
+                error.downcast_ref::<IvcCircuitError>(),
+                Some(IvcCircuitError::IvcVerificationKeyDegreeMismatch { actual: 20, .. })
+            ),
+            "expected a degree mismatch, got: {error}"
+        );
+    }
+
+    // Deriving Deserialize would otherwise reach the dependency's reader without the guard, and
+    // that is the path the verifier data envelopes take.
+    #[test]
+    fn serde_rejects_a_certificate_verifying_key_in_the_recursive_position() {
+        let encoded = serde_json::to_vec(&serde_bytes::ByteBuf::from(
+            NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec(),
+        ))
+        .expect("the certificate key bytes should encode");
+
+        let error = serde_json::from_slice::<RecursiveCircuitVerifyingKey>(&encoded)
+            .expect_err("a certificate key must not deserialize as a recursive one");
+
+        assert!(
+            error.to_string().contains("architecture"),
+            "expected an architecture mismatch, got: {error}"
+        );
+    }
+
+    // The proving key opens with its own degree, taken into the same `k - 1` arithmetic.
+    #[test]
+    fn a_proving_key_of_the_wrong_degree_is_rejected() {
+        let error = match RecursiveCircuitProvingKey::try_from_bytes(&[0u8; 8]) {
+            Ok(_) => panic!("a zero degree proving key must be rejected"),
+            Err(error) => error,
+        };
+
+        assert!(
+            matches!(
+                error.downcast_ref::<IvcCircuitError>(),
+                Some(IvcCircuitError::IvcVerificationKeyDegreeMismatch { actual: 0, .. })
+            ),
+            "expected a degree mismatch, got: {error}"
+        );
+    }
+
+    // A standalone encoding holds one key and nothing else, so anything appended is a decoder
+    // disagreement rather than harmless padding.
+    #[test]
+    fn a_standalone_encoding_with_trailing_bytes_is_rejected() {
+        let mut bytes = RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec();
+        bytes.extend_from_slice(&[0u8; 4]);
+
+        let error = RecursiveCircuitVerifyingKey::try_from_bytes(&bytes)
+            .expect_err("trailing bytes must be rejected");
+
+        assert!(
+            matches!(
+                error.downcast_ref::<IvcCircuitError>(),
+                Some(IvcCircuitError::RecursiveKeyEncodingHasTrailingBytes { trailing: 4 })
+            ),
+            "expected trailing bytes, got: {error}"
+        );
+    }
+
+    // The reader takes the commitment count from the bytes and reads that many, so a key can
+    // declare fewer than the configured constraint system has columns.
+    #[test]
+    fn a_key_declaring_too_few_fixed_commitments_is_rejected() {
+        use midnight_proofs::utils::helpers::byte_length;
+
+        let mut reader = RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+        ZkStdLibArch::read_from_serialized_vk(&mut reader).expect("architecture should read");
+        // envelope degree, public input count, then the raw key's version and degree
+        let count_index =
+            RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.len() - reader.len() + 1 + 4 + 2;
+
+        let mut bytes = RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec();
+        let declared = u32::from_le_bytes(bytes[count_index..count_index + 4].try_into().unwrap());
+        assert_eq!(
+            declared as usize,
+            RecursiveCircuitVerifyingKey::expected_fixed_commitment_count(),
+            "the production key should declare the configured commitment count"
+        );
+
+        // Drop one commitment along with the count, so the encoding stays internally consistent and
+        // fully consumed: only the cardinality guard can reject it.
+        let commitment_length = byte_length::<
+            <KZGCommitmentScheme<PairingEngine> as midnight_proofs::poly::commitment::PolynomialCommitmentScheme<NativeField>>::Commitment,
+        >(KEY_SERDE_FORMAT);
+        let commitments_start = count_index + 4;
+        bytes.drain(commitments_start..commitments_start + commitment_length);
+        bytes[count_index..count_index + 4].copy_from_slice(&(declared - 1).to_le_bytes());
+
+        let error = RecursiveCircuitVerifyingKey::try_from_bytes(&bytes)
+            .expect_err("a short commitment count must be rejected");
+
+        assert!(
+            matches!(
+                error.downcast_ref::<IvcCircuitError>(),
+                Some(IvcCircuitError::RecursiveVerificationKeyCommitmentCountMismatch {
+                    actual,
+                    ..
+                }) if *actual as u32 == declared - 1
+            ),
+            "expected a commitment count mismatch, got: {error}"
+        );
+    }
+
+    // The relation's certificate key declares a degree twice and the reader takes them
+    // independently, so a supported envelope can wrap a raw key of any other degree.
+    #[test]
+    fn a_proving_key_whose_certificate_inner_degree_disagrees_is_rejected() {
+        use crate::circuits::halo2::NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+
+        let mut certificate_key = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec();
+        let mut reader = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+        ZkStdLibArch::read_from_serialized_vk(&mut reader).expect("architecture should read");
+        let raw_degree_index =
+            NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.len() - reader.len() + 1 + 4 + 1;
+        certificate_key[raw_degree_index] = 32;
+
+        // A proving key encoding: its degree, then the length prefixed relation.
+        let mut bytes = vec![RECURSIVE_CIRCUIT_DEGREE as u8];
+        bytes.extend_from_slice(&(certificate_key.len() as u32).to_le_bytes());
+        bytes.extend_from_slice(&certificate_key);
+        bytes.extend_from_slice(&[0u8; 8]);
+
+        let error = match RecursiveCircuitProvingKey::try_from_bytes(&bytes) {
+            Ok(_) => panic!("a disagreeing certificate degree must be rejected"),
+            Err(error) => error,
+        };
+
+        assert!(
+            matches!(
+                error.downcast_ref::<IvcCircuitError>(),
+                Some(IvcCircuitError::IvcVerificationKeyDegreeMismatch { actual: 32, .. })
+            ),
+            "expected a degree mismatch, got: {error}"
+        );
+    }
 }
diff --git a/mithril-stm/src/circuits/halo2_ivc/mod.rs b/mithril-stm/src/circuits/halo2_ivc/mod.rs
index f0caa5a2b55..94810e063b5 100644
--- a/mithril-stm/src/circuits/halo2_ivc/mod.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/mod.rs
@@ -31,7 +31,7 @@ pub(crate) use midnight_circuits::{
 
 pub(crate) use midnight_proofs::{
     circuit::{Layouter, Value},
-    plonk::{ConstraintSystem, Error, ProvingKey, VerifyingKey},
+    plonk::{ConstraintSystem, Error, VerifyingKey},
     poly::{EvaluationDomain, kzg::KZGCommitmentScheme},
 };
 
@@ -48,8 +48,6 @@ pub(crate) mod errors;
 pub(crate) mod gadgets;
 pub(crate) mod io;
 #[cfg_attr(not(test), allow(dead_code))]
-pub(crate) mod key_serialization;
-#[cfg_attr(not(test), allow(dead_code))]
 pub(crate) mod keys;
 #[cfg(test)]
 pub(crate) mod protocol_message;
diff --git a/mithril-stm/src/circuits/halo2_ivc/recursive_circuit_verification_key_for_production.bin b/mithril-stm/src/circuits/halo2_ivc/recursive_circuit_verification_key_for_production.bin
index 89b19f59e410655c5ba1a8b2a00ce042db797b82..aa7513b71dccfeafaa66fbf1502bb7fc121c0507 100644
GIT binary patch
delta 31
gcmZ3czgJ(JiGhKEk&zKdf*3%|B3uC^H!Kqe06we(+W-In

delta 8
Pcmdn1zf6Cl_%d+-5Of1a

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/golden_recursive_circuit_verification_key.bin b/mithril-stm/src/circuits/halo2_ivc/tests/assets/golden_recursive_circuit_verification_key.bin
index c57615eb5e7032a05acff4aef160f85996c0268b..872b226061bb98c13879f8be51eda55e32b9d8e9 100644
GIT binary patch
delta 31
gcmZ3czgJ(JiGhKEk&zKdf*3%|B3uC^H!Kqe06we(+W-In

delta 8
Pcmdn1zf6Cl_%d+-5Of1a

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/verification_context.bin b/mithril-stm/src/circuits/halo2_ivc/tests/assets/verification_context.bin
index d08b7d3322e80dcabd8a4fa86fa523058eb1d27c..8d3c3f21db0387f49da4196bfec8d9771459ec9b 100644
GIT binary patch
delta 36
lcmbQXlyU7+#t93=nHU%t7#SIXB!~gTEW#B)a^r$;fdGhi2Lu2B

delta 12
UcmZ3xlyTZp#t92HZvPet04HPyZvX%Q

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/asset_readers.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/asset_readers.rs
index 5a51d59de54..5afe123c6c1 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/asset_readers.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/asset_readers.rs
@@ -136,7 +136,7 @@ pub(crate) fn store_verification_context_asset(
     }
     asset
         .recursive_verifying_key
-        .verifying_key()
+        .midnight_vk()
         .write(&mut writer, SerdeFormat::RawBytesUnchecked)?;
     write_named_fixed_bases(&mut writer, &asset.combined_fixed_bases)?;
 
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs
index 36bc2f2cad2..cb2a662c69e 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs
@@ -46,7 +46,7 @@ where
         MidnightCircuit<IvcCircuit>,
     >(
         commitment_parameters,
-        proving_key.proving_key(),
+        proving_key.midnight_pk().pk(),
         std::slice::from_ref(&MidnightCircuit::new(
             ivc_circuit,
             Value::known(public_inputs.to_vec()),
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs
index 53fbefded9e..144cb33c632 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs
@@ -1,4 +1,4 @@
-use midnight_zk_stdlib::MidnightCircuit;
+use midnight_zk_stdlib::{self as zk};
 use std::{
     collections::BTreeMap,
     io::Write,
@@ -7,10 +7,7 @@ use std::{
 
 use ff::Field;
 use midnight_curves::Bls12;
-use midnight_proofs::{
-    plonk::{keygen_pk, keygen_vk_with_k},
-    poly::kzg::params::{ParamsKZG, ParamsVerifierKZG},
-};
+use midnight_proofs::poly::kzg::params::{ParamsKZG, ParamsVerifierKZG};
 use midnight_zk_stdlib as zk_lib;
 use rand_chacha::ChaCha20Rng;
 use rand_core::{CryptoRng, RngCore, SeedableRng};
@@ -218,14 +215,10 @@ fn derive_recursive_verifying_key(
     certificate_verifying_key: &NonRecursiveCircuitVerifyingKey,
 ) -> RecursiveCircuitVerifyingKey {
     let default_ivc_circuit = IvcCircuit::for_key_generation(certificate_verifying_key);
-    RecursiveCircuitVerifyingKey::new(
-        keygen_vk_with_k(
-            recursive_commitment_parameters,
-            &MidnightCircuit::from_relation(&default_ivc_circuit, Some(RECURSIVE_CIRCUIT_DEGREE)),
-            RECURSIVE_CIRCUIT_DEGREE,
-        )
-        .expect("recursive verifying key generation should not fail"),
-    )
+    RecursiveCircuitVerifyingKey::new(zk::setup_vk(
+        recursive_commitment_parameters,
+        &default_ivc_circuit,
+    ))
 }
 
 /// Content-keyed cache entry holding the recursive verifying key derived from these inputs.
@@ -422,13 +415,10 @@ pub(crate) fn build_recursive_proving_key(
     context: &SharedRecursiveContext,
 ) -> RecursiveCircuitProvingKey {
     let default_ivc_circuit = IvcCircuit::for_key_generation(&context.certificate_verifying_key);
-    RecursiveCircuitProvingKey::new(
-        keygen_pk(
-            context.recursive_verifying_key.verifying_key().clone(),
-            &MidnightCircuit::from_relation(&default_ivc_circuit, Some(RECURSIVE_CIRCUIT_DEGREE)),
-        )
-        .expect("recursive proving key generation should not fail"),
-    )
+    RecursiveCircuitProvingKey::new(zk::setup_pk(
+        &default_ivc_circuit,
+        context.recursive_verifying_key.midnight_vk(),
+    ))
 }
 
 /// Returns the certificate, recursive, and combined fixed-base maps.
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/verification_key.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/verification_key.rs
index b84c43ffd0d..53e17c6c2ec 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/verification_key.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/verification_key.rs
@@ -1,18 +1,14 @@
 use std::path::Path;
 
-use midnight_proofs::{
-    plonk::{VerifyingKey, keygen_vk_with_k},
-    poly::kzg::KZGCommitmentScheme,
-    utils::SerdeFormat,
-};
-use midnight_zk_stdlib::MidnightCircuit;
+use midnight_proofs::utils::SerdeFormat;
+use midnight_zk_stdlib::{self as zk, MidnightCircuit};
 
 use crate::{
     Parameters,
     circuits::{
         halo2::circuit::CertificateCircuit,
         halo2::keys::NonRecursiveCircuitVerifyingKey,
-        halo2_ivc::{NativeField, PairingEngine, RECURSIVE_CIRCUIT_DEGREE, circuit::IvcCircuit},
+        halo2_ivc::{RECURSIVE_CIRCUIT_DEGREE, circuit::IvcCircuit},
     },
 };
 
@@ -40,13 +36,7 @@ pub(crate) fn golden_recursive_circuit_verification_key_bytes() -> Vec<u8> {
     );
 
     let default_ivc_circuit = IvcCircuit::for_key_generation(&circuit_verification_key);
-    let recursive_verifying_key: VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>> =
-        keygen_vk_with_k(
-            &srs_for_recursive_circuit,
-            &MidnightCircuit::from_relation(&default_ivc_circuit, Some(RECURSIVE_CIRCUIT_DEGREE)),
-            RECURSIVE_CIRCUIT_DEGREE,
-        )
-        .expect("recursive verifying key generation should not fail");
+    let recursive_verifying_key = zk::setup_vk(&srs_for_recursive_circuit, &default_ivc_circuit);
 
     let mut buf_cvk = vec![];
     recursive_verifying_key
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/off_circuit/circuit_validation.rs b/mithril-stm/src/circuits/halo2_ivc/tests/off_circuit/circuit_validation.rs
index 889c0f7edcd..a3c451f3f53 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/off_circuit/circuit_validation.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/off_circuit/circuit_validation.rs
@@ -14,7 +14,7 @@ fn validate_ivc_verification_key_degree_rejects_wrong_degree_vk() {
     let ctx =
         load_embedded_verification_context_asset().expect("verification context asset should load");
     let wrong_degree_vk =
-        RecursiveCircuitVerifyingKey::new(ctx.certificate_verifying_key.midnight_vk().vk().clone());
+        RecursiveCircuitVerifyingKey::new(ctx.certificate_verifying_key.midnight_vk().clone());
     let actual_degree = wrong_degree_vk.verifying_key().get_domain().k();
 
     let result = IvcCircuit::validate_ivc_verification_key_degree(&wrong_degree_vk);
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/verification_key_computation.rs b/mithril-stm/src/circuits/halo2_ivc/tests/verification_key_computation.rs
index c131dd8d6f6..fa6dae5038b 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/verification_key_computation.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/verification_key_computation.rs
@@ -1,10 +1,6 @@
 use anyhow::Context;
-use midnight_proofs::{
-    plonk::{VerifyingKey, keygen_vk_with_k},
-    poly::kzg::KZGCommitmentScheme,
-    utils::SerdeFormat,
-};
-use midnight_zk_stdlib::{MidnightCircuit, MidnightVK};
+use midnight_proofs::utils::SerdeFormat;
+use midnight_zk_stdlib::{self as zk, MidnightVK};
 
 use crate::{
     StmResult,
@@ -14,8 +10,8 @@ use crate::{
             keys::NonRecursiveCircuitVerifyingKey,
         },
         halo2_ivc::{
-            NativeField, PairingEngine, RECURSIVE_CIRCUIT_DEGREE,
-            RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION, circuit::IvcCircuit,
+            RECURSIVE_CIRCUIT_DEGREE, RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
+            circuit::IvcCircuit,
         },
         trusted_setup::TrustedSetupProvider,
     },
@@ -38,12 +34,8 @@ fn compute_recursive_circuit_verification_key() -> StmResult<Vec<u8>> {
     );
 
     let default_ivc_circuit = IvcCircuit::for_key_generation(&certificate_verifying_key);
-    let recursive_verification_key: VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>> =
-        keygen_vk_with_k(
-            &recursive_commitment_parameters,
-            &MidnightCircuit::from_relation(&default_ivc_circuit, Some(RECURSIVE_CIRCUIT_DEGREE)),
-            shared_srs_degree,
-        )?;
+    let recursive_verification_key =
+        zk::setup_vk(&recursive_commitment_parameters, &default_ivc_circuit);
 
     let mut buffer_for_recursive_circuit_verification_key = vec![];
     recursive_verification_key
diff --git a/mithril-stm/src/circuits/trusted_setup.rs b/mithril-stm/src/circuits/trusted_setup.rs
index 61b754d286f..caa8bfbd48a 100644
--- a/mithril-stm/src/circuits/trusted_setup.rs
+++ b/mithril-stm/src/circuits/trusted_setup.rs
@@ -22,6 +22,8 @@ use {rand_chacha::ChaCha20Rng, rand_core::SeedableRng, std::fs::create_dir_all};
 /// the proper value available here: https://github.com/midnightntwrk/midnight-trusted-setup/blob/main/MIDNIGHT_SRS_CATALOG.md
 pub(crate) const MIDNIGHT_SRS_HASH_K22: &str =
     "e8ad5eed936d657a0fb59d2a55ba19f81a3083bb3554ef88f464f5377e9b2c2f";
+/// Degree of the SRS the two hashes above identify: the largest circuit it can support.
+pub(crate) const MIDNIGHT_SRS_DEGREE: u8 = 22;
 /// Constant storing URL to download the SRS of degree 22 used to create proof in production
 const MIDNIGHT_SRS_URL_K22: &str = "https://srs.midnight.network/midnight-srs-2p22";
 /// Constant holding the folder of the SRS file
diff --git a/mithril-stm/src/proof_system/halo2_ivc_snark/proof.rs b/mithril-stm/src/proof_system/halo2_ivc_snark/proof.rs
index 2f430a51621..9e0965a8f0e 100644
--- a/mithril-stm/src/proof_system/halo2_ivc_snark/proof.rs
+++ b/mithril-stm/src/proof_system/halo2_ivc_snark/proof.rs
@@ -303,7 +303,7 @@ where
             MidnightCircuit<IvcCircuit>,
         >(
             srs,
-            proving_key.proving_key(),
+            proving_key.midnight_pk().pk(),
             std::slice::from_ref(&circuit),
             1,
             &[&[&[], public_inputs]],
diff --git a/mithril-stm/src/proof_system/halo2_ivc_snark/verifier_setup.rs b/mithril-stm/src/proof_system/halo2_ivc_snark/verifier_setup.rs
index 0a002b79c9e..315d11774f6 100644
--- a/mithril-stm/src/proof_system/halo2_ivc_snark/verifier_setup.rs
+++ b/mithril-stm/src/proof_system/halo2_ivc_snark/verifier_setup.rs
@@ -331,4 +331,52 @@ mod tests {
             "embedded IVC verifier params must match the Midnight trusted SRS"
         );
     }
+    // The recursive key's guard must hold at the public envelope, not only at the byte codec: this
+    // is the path a certificate carries, and the two circuits now share one key encoding.
+    #[test]
+    fn verifier_data_rejects_a_certificate_key_in_the_recursive_position() {
+        use crate::circuits::halo2::NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+        use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+
+        // Mirrors `IvcVerifierData`'s CBOR shape with both keys as opaque bytes, so the recursive
+        // slot can carry an encoding the typed constructor would never allow.
+        #[derive(serde::Serialize)]
+        struct VerifierDataWithOpaqueKeys {
+            genesis_message: MessageHash,
+            #[serde(with = "serde_bytes")]
+            certificate_circuit_verification_key: Vec<u8>,
+            #[serde(with = "serde_bytes")]
+            ivc_circuit_verification_key: Vec<u8>,
+        }
+
+        let tampered = VerifierDataWithOpaqueKeys {
+            genesis_message: MessageHash::ZERO,
+            certificate_circuit_verification_key:
+                NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec(),
+            // A certificate key where the recursive one belongs.
+            ivc_circuit_verification_key: NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION
+                .to_vec(),
+        };
+        let bytes = crate::codec::to_cbor_bytes(&tampered).expect("the mirror should encode");
+
+        let error = IvcVerifierData::from_bytes(&bytes)
+            .expect_err("a certificate key must not decode in the recursive position");
+        assert!(
+            error.to_string().contains("architecture")
+                || format!("{error:#}").contains("architecture"),
+            "expected an architecture mismatch, got: {error:#}"
+        );
+
+        // The same envelope with the real recursive key decodes, so the rejection is the guard and
+        // not the mirror's shape.
+        let valid = VerifierDataWithOpaqueKeys {
+            genesis_message: MessageHash::ZERO,
+            certificate_circuit_verification_key:
+                NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec(),
+            ivc_circuit_verification_key: RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION
+                .to_vec(),
+        };
+        let bytes = crate::codec::to_cbor_bytes(&valid).expect("the mirror should encode");
+        IvcVerifierData::from_bytes(&bytes).expect("the real recursive key should decode");
+    }
 }
diff --git a/mithril-stm/src/protocol/aggregate_signature/ancillary_data.rs b/mithril-stm/src/protocol/aggregate_signature/ancillary_data.rs
index b7cf8b21f4f..bcde56bb61e 100644
--- a/mithril-stm/src/protocol/aggregate_signature/ancillary_data.rs
+++ b/mithril-stm/src/protocol/aggregate_signature/ancillary_data.rs
@@ -499,8 +499,8 @@ mod tests {
         use sha2::{Digest, Sha256};
 
         const EXPECTED_IVC_ANCILLARY_DIGEST: [u8; 32] = [
-            166, 23, 43, 148, 143, 254, 123, 150, 165, 210, 35, 250, 36, 248, 222, 137, 180, 56,
-            75, 253, 228, 42, 64, 179, 144, 17, 68, 254, 99, 93, 223, 242,
+            162, 102, 123, 88, 167, 76, 76, 67, 63, 218, 224, 79, 162, 202, 132, 227, 110, 187, 18,
+            66, 152, 52, 140, 146, 184, 113, 211, 232, 230, 224, 207, 242,
         ];
         let context = load_embedded_verification_context_asset()
             .expect("verification context asset should load");

From c733b29d37b293021e81d0c630492ecab54ccf2a Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Wed, 16 Sep 2026 16:54:37 +0900
Subject: [PATCH 05/14] docs(stm): record why the recursive range column count
 cannot be lowered

---
 mithril-stm/src/circuits/halo2_ivc/circuit.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mithril-stm/src/circuits/halo2_ivc/circuit.rs b/mithril-stm/src/circuits/halo2_ivc/circuit.rs
index 63661ec9fab..4cf8e029e19 100644
--- a/mithril-stm/src/circuits/halo2_ivc/circuit.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/circuit.rs
@@ -30,6 +30,7 @@ pub(crate) fn recursive_circuit_architecture() -> ZkStdLibArch {
         secp256k1: false,
         bls12_381: true,
         base64: false,
+        // With production certificate metadata, 1 to 3 range columns require k=20 instead of k=19.
         nr_pow2range_cols: 4,
         automaton: false,
         blake2b: false,

From 9e2b3574b9770d1acc9361825ed331dcc397c563 Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Wed, 16 Sep 2026 16:56:48 +0900
Subject: [PATCH 06/14] docs(stm): document the source constants that
 regeneration must update

---
 .../circuits/halo2_ivc/tests/assets/README.md | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/README.md b/mithril-stm/src/circuits/halo2_ivc/tests/assets/README.md
index 20e79930934..7ce8dec7dc8 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/assets/README.md
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/assets/README.md
@@ -83,6 +83,40 @@ cargo test -p mithril-stm --features future_snark,rustls --release generate_recu
 These commands intentionally use `--release` because asset generation is a
 manual workflow dominated by real proof generation.
 
+## Source Constants To Update
+
+Regenerating the binaries is only half the work. Four constants are pinned in source and are not
+written by any generator.
+
+| Constant | File | Test that computes it | Computed value appears |
+|---|---|---|---|
+| production recursive key digest | `circuits/verification_key_digest.rs` | `golden_digests_of_production_circuit_keys` | right |
+| verification-context recursive key digest | `circuits/verification_key_digest.rs` | `golden_digests_of_embedded_verification_context_keys` | right |
+| `GOLDEN_R` combiner challenge | `proof_system/halo2_ivc_snark/proof.rs` | `golden_combiner_r_for_stored_recursive_step_output` | left |
+| `EXPECTED_IVC_ANCILLARY_DIGEST` | `protocol/aggregate_signature/ancillary_data.rs` | `ivc_ancillary_encoding_is_byte_stable` | left |
+
+The assertions are not written the same way round, so check the last column before copying a value:
+taking the wrong side copies the old expected value back, leaving the test failing.
+
+Each constant binds something different, which is what decides whether it moves:
+
+- The two key digests bind the raw verifying key's **transcript representation**.
+- `GOLDEN_R` binds the **proof verification transcript and accumulator**.
+- `EXPECTED_IVC_ANCILLARY_DIGEST` binds the **complete encoded CBOR**, embedded keys included.
+
+These four checks compute golden values; they do not establish validity. Confirm the regenerated keys
+and proofs pass their integrity and verification checks before updating any constant — the
+`GOLDEN_R` test in particular prepares the transcript without performing the final pairing check —
+then rerun the golden checks.
+
+So the rule is not to predict which will move. Rerun all four checks after regenerating, and update
+only those whose inputs you deliberately changed. Some cases are counter-intuitive: a constraint
+system change can alter a transcript representation without altering the serialized commitments; a
+key encoding change moves only the ancillary digest, since the other three never see the envelope;
+and regenerating a randomized proof can move `GOLDEN_R` even when the circuit identity is untouched.
+
+If a value changes and you cannot say which input caused it, stop and find out before updating it.
+
 ## When Regeneration Is Needed
 
 Regenerate the assets when one of these changes:

From 7a53233e0d70bbcff1608e919b6ba5fa7216661b Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Thu, 17 Sep 2026 08:16:16 +0900
Subject: [PATCH 07/14] docs(stm): format the source constants table with
 prettier

---
 .../src/circuits/halo2_ivc/tests/assets/README.md    | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/assets/README.md b/mithril-stm/src/circuits/halo2_ivc/tests/assets/README.md
index 7ce8dec7dc8..9a2375fe0de 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/assets/README.md
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/assets/README.md
@@ -88,12 +88,12 @@ manual workflow dominated by real proof generation.
 Regenerating the binaries is only half the work. Four constants are pinned in source and are not
 written by any generator.
 
-| Constant | File | Test that computes it | Computed value appears |
-|---|---|---|---|
-| production recursive key digest | `circuits/verification_key_digest.rs` | `golden_digests_of_production_circuit_keys` | right |
-| verification-context recursive key digest | `circuits/verification_key_digest.rs` | `golden_digests_of_embedded_verification_context_keys` | right |
-| `GOLDEN_R` combiner challenge | `proof_system/halo2_ivc_snark/proof.rs` | `golden_combiner_r_for_stored_recursive_step_output` | left |
-| `EXPECTED_IVC_ANCILLARY_DIGEST` | `protocol/aggregate_signature/ancillary_data.rs` | `ivc_ancillary_encoding_is_byte_stable` | left |
+| Constant                                  | File                                             | Test that computes it                                  | Computed value appears |
+| ----------------------------------------- | ------------------------------------------------ | ------------------------------------------------------ | ---------------------- |
+| production recursive key digest           | `circuits/verification_key_digest.rs`            | `golden_digests_of_production_circuit_keys`            | right                  |
+| verification-context recursive key digest | `circuits/verification_key_digest.rs`            | `golden_digests_of_embedded_verification_context_keys` | right                  |
+| `GOLDEN_R` combiner challenge             | `proof_system/halo2_ivc_snark/proof.rs`          | `golden_combiner_r_for_stored_recursive_step_output`   | left                   |
+| `EXPECTED_IVC_ANCILLARY_DIGEST`           | `protocol/aggregate_signature/ancillary_data.rs` | `ivc_ancillary_encoding_is_byte_stable`                | left                   |
 
 The assertions are not written the same way round, so check the last column before copying a value:
 taking the wrong side copies the old expected value back, leaving the test failing.

From 8d7ef8d74e9aa055cda7ece84664b42aa605689e Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Fri, 18 Sep 2026 08:11:16 +0900
Subject: [PATCH 08/14] fix(stm): guard the certificate verifying key decoder

---
 mithril-stm/src/circuits/halo2/circuit.rs     |  40 +--
 mithril-stm/src/circuits/halo2/errors.rs      |  13 +
 mithril-stm/src/circuits/halo2/keys.rs        | 231 +++++++++++++++++-
 mithril-stm/src/circuits/halo2_ivc/keys.rs    |  57 +----
 mithril-stm/src/circuits/key_serialization.rs |  32 +--
 5 files changed, 273 insertions(+), 100 deletions(-)

diff --git a/mithril-stm/src/circuits/halo2/circuit.rs b/mithril-stm/src/circuits/halo2/circuit.rs
index 5d146443b19..167c2c5df29 100644
--- a/mithril-stm/src/circuits/halo2/circuit.rs
+++ b/mithril-stm/src/circuits/halo2/circuit.rs
@@ -23,6 +23,29 @@ use crate::signature_scheme::{
 };
 use crate::{LotteryIndex, Parameters, StmResult};
 
+/// Chips the certificate circuit enables.
+///
+/// Single source: the relation declares these to the standard library, and the key decoder checks
+/// an encoded key against the same value, so the two cannot drift.
+pub(crate) fn certificate_circuit_architecture() -> ZkStdLibArch {
+    ZkStdLibArch {
+        jubjub: true,
+        poseidon: true,
+        sha2_256: false,
+        sha2_512: false,
+        keccak_256: false,
+        sha3_256: false,
+        secp256k1: false,
+        bls12_381: false,
+        base64: false,
+        nr_pow2range_cols: 2,
+        automaton: false,
+        blake2b: false,
+        curve25519: false,
+        p256: false,
+    }
+}
+
 /// Halo2 relation implementing the non-recursive STM verification circuit.
 ///
 /// Carries only the parameters that fix the constraint system; the instance and witness are
@@ -296,22 +319,7 @@ impl Relation for CertificateCircuit {
     }
 
     fn used_chips(&self) -> ZkStdLibArch {
-        ZkStdLibArch {
-            jubjub: true,
-            poseidon: true,
-            sha2_256: false,
-            sha2_512: false,
-            keccak_256: false,
-            sha3_256: false,
-            secp256k1: false,
-            bls12_381: false,
-            base64: false,
-            nr_pow2range_cols: 2,
-            automaton: false,
-            blake2b: false,
-            curve25519: false,
-            p256: false,
-        }
+        certificate_circuit_architecture()
     }
 
     fn write_relation<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
diff --git a/mithril-stm/src/circuits/halo2/errors.rs b/mithril-stm/src/circuits/halo2/errors.rs
index 39881efff37..fe5b6644921 100644
--- a/mithril-stm/src/circuits/halo2/errors.rs
+++ b/mithril-stm/src/circuits/halo2/errors.rs
@@ -115,6 +115,19 @@ pub enum CertificateCircuitError {
     /// A proving/verification backend error surfaced at the relation boundary.
     #[error("Backend error: {0}")]
     Backend(String),
+
+    /// An encoded verification key declares an architecture that is not the certificate circuit's.
+    #[error("The encoded key does not declare the certificate circuit architecture")]
+    VerificationKeyArchitectureMismatch,
+
+    /// An encoded verification key declares a degree no certificate circuit could have been
+    /// generated with, or declares two degrees that disagree.
+    #[error("Certificate verification key degree mismatch: expected {expected}, got {actual}")]
+    VerificationKeyDegreeMismatch { expected: u32, actual: u32 },
+
+    /// A standalone encoded verification key is followed by bytes that are not part of it.
+    #[error("The encoded certificate verification key has {trailing} trailing byte(s)")]
+    VerificationKeyEncodingHasTrailingBytes { trailing: usize },
 }
 
 impl From<PlonkError> for CertificateCircuitError {
diff --git a/mithril-stm/src/circuits/halo2/keys.rs b/mithril-stm/src/circuits/halo2/keys.rs
index 8726402f0e5..20d49331594 100644
--- a/mithril-stm/src/circuits/halo2/keys.rs
+++ b/mithril-stm/src/circuits/halo2/keys.rs
@@ -2,24 +2,29 @@
 // implementation of [`KeyGenerator`]. The newtypes wrap Midnight's self-describing
 // `MidnightVK` / `MidnightPK` and delegate their byte (de)serialization to the impls in
 // `key_serialization`.
+use std::io::Read;
+
+use anyhow::{Context, anyhow};
 use midnight_curves::Bls12;
 use midnight_proofs::poly::commitment::Params;
 use midnight_proofs::poly::kzg::params::ParamsKZG;
-use midnight_zk_stdlib::{self as zk, MidnightCircuit, MidnightPK, MidnightVK};
+use midnight_zk_stdlib::{self as zk, MidnightCircuit, MidnightPK, MidnightVK, ZkStdLibArch};
 use serde::{Deserialize, Serialize};
 
 use crate::StmResult;
+use crate::circuits::halo2::errors::CertificateCircuitError;
 use crate::circuits::halo2_ivc::{KZGCommitmentScheme, NativeField, PairingEngine, VerifyingKey};
 use crate::circuits::key_generator::KeyGenerator;
-use crate::circuits::key_serialization::midnight_verifying_key_serde;
+use crate::circuits::key_serialization::KEY_SERDE_FORMAT;
+use crate::circuits::trusted_setup::MIDNIGHT_SRS_DEGREE;
 use crate::codec::{TryFromBytes, TryToBytes};
 
-use super::circuit::CertificateCircuit;
+use super::circuit::{CertificateCircuit, certificate_circuit_architecture};
 
 /// Verifying key of the non-recursive certificate circuit.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub(crate) struct NonRecursiveCircuitVerifyingKey(
-    #[serde(with = "midnight_verifying_key_serde")] MidnightVK,
+    #[serde(with = "certificate_verifying_key_serde")] MidnightVK,
 );
 
 /// Proving key of the non-recursive certificate circuit.
@@ -42,6 +47,64 @@ impl NonRecursiveCircuitVerifyingKey {
     pub(crate) fn circuit_degree(&self) -> u32 {
         self.midnight_vk().vk().get_domain().k()
     }
+
+    /// Checks the header of an encoded certificate verifying key before it is decoded.
+    ///
+    /// `MidnightVK` takes its architecture and degree from the bytes, so without this any Midnight
+    /// circuit's key decodes in the certificate position — including the recursive circuit's, which
+    /// this crate now encodes the same way.
+    ///
+    /// Certificate degrees legitimately vary — production, the full fixture and the small golden
+    /// context all differ — so they are bounded by the trusted setup rather than pinned. The key
+    /// declares one twice, once in its Midnight envelope and once in the raw key it wraps, and the
+    /// reader takes them independently: each reaches a `k - 1` subtraction on a byte, which
+    /// underflows at zero, or a domain constructor that asserts.
+    pub(crate) fn validate_encoded_header(bytes: &[u8]) -> StmResult<()> {
+        let mut reader = bytes;
+        let architecture = ZkStdLibArch::read_from_serialized_vk(&mut reader)
+            .with_context(|| "Failed to read the certificate verifying key architecture")?;
+        if architecture != certificate_circuit_architecture() {
+            return Err(anyhow!(
+                CertificateCircuitError::VerificationKeyArchitectureMismatch
+            ));
+        }
+
+        let mut envelope_degree = [0u8; 1];
+        reader
+            .read_exact(&mut envelope_degree)
+            .with_context(|| "Failed to read the certificate verifying key degree")?;
+
+        let mut public_input_count = [0u8; 4];
+        reader
+            .read_exact(&mut public_input_count)
+            .with_context(|| "Failed to read the certificate verifying key public input count")?;
+
+        // The wrapped raw key opens with its own version and degree.
+        let mut raw_header = [0u8; 2];
+        reader
+            .read_exact(&mut raw_header)
+            .with_context(|| "Failed to read the wrapped raw certificate key header")?;
+
+        for degree in [envelope_degree[0], raw_header[1]] {
+            if degree == 0 || degree > MIDNIGHT_SRS_DEGREE {
+                return Err(anyhow!(
+                    CertificateCircuitError::VerificationKeyDegreeMismatch {
+                        expected: u32::from(MIDNIGHT_SRS_DEGREE),
+                        actual: u32::from(degree),
+                    }
+                ));
+            }
+        }
+        if envelope_degree[0] != raw_header[1] {
+            return Err(anyhow!(
+                CertificateCircuitError::VerificationKeyDegreeMismatch {
+                    expected: u32::from(envelope_degree[0]),
+                    actual: u32::from(raw_header[1]),
+                }
+            ));
+        }
+        Ok(())
+    }
 }
 
 impl AsRef<VerifyingKey<NativeField, KZGCommitmentScheme<PairingEngine>>>
@@ -59,6 +122,33 @@ impl NonRecursiveCircuitProvingKey {
     }
 }
 
+/// Serde for the wrapped Midnight verifying key, routed through the newtype's guarded byte decoder
+/// so the verifier-data envelopes cannot reach the dependency's readers unchecked.
+mod certificate_verifying_key_serde {
+    use midnight_zk_stdlib::MidnightVK;
+    use serde::{Deserializer, Serializer};
+
+    use super::NonRecursiveCircuitVerifyingKey;
+    use crate::codec::{TryFromBytes, TryToBytes};
+
+    pub(super) fn serialize<S: Serializer>(
+        verifying_key: &MidnightVK,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let bytes = verifying_key.to_bytes_vec().map_err(serde::ser::Error::custom)?;
+        serializer.serialize_bytes(&bytes)
+    }
+
+    pub(super) fn deserialize<'de, D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<MidnightVK, D::Error> {
+        let bytes: Vec<u8> = serde::Deserialize::deserialize(deserializer)?;
+        NonRecursiveCircuitVerifyingKey::try_from_bytes(&bytes)
+            .map(|key| key.0)
+            .map_err(serde::de::Error::custom)
+    }
+}
+
 impl TryToBytes for NonRecursiveCircuitVerifyingKey {
     fn to_bytes_vec(&self) -> StmResult<Vec<u8>> {
         self.0.to_bytes_vec()
@@ -67,7 +157,22 @@ impl TryToBytes for NonRecursiveCircuitVerifyingKey {
 
 impl TryFromBytes for NonRecursiveCircuitVerifyingKey {
     fn try_from_bytes(bytes: &[u8]) -> StmResult<Self> {
-        Ok(Self(MidnightVK::try_from_bytes(bytes)?))
+        Self::validate_encoded_header(bytes)?;
+
+        let mut reader = bytes;
+        let midnight_vk = MidnightVK::read(&mut reader, KEY_SERDE_FORMAT)
+            .with_context(|| "Failed to deserialize the certificate verifying key")?;
+        // A standalone encoding holds one key and nothing else; the streaming asset reader, where a
+        // fixed-base map follows the key, deliberately does not go through here.
+        if !reader.is_empty() {
+            return Err(anyhow!(
+                CertificateCircuitError::VerificationKeyEncodingHasTrailingBytes {
+                    trailing: reader.len(),
+                }
+            ));
+        }
+
+        Ok(Self(midnight_vk))
     }
 }
 
@@ -124,10 +229,14 @@ mod tests {
     use rand_chacha::ChaCha20Rng;
     use rand_core::SeedableRng;
 
+    use midnight_zk_stdlib::ZkStdLibArch;
+
     use super::{NonRecursiveCircuitProvingKey, NonRecursiveCircuitVerifyingKey};
     use crate::Parameters;
     use crate::circuits::halo2::NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
     use crate::circuits::halo2::circuit::CertificateCircuit;
+    use crate::circuits::halo2::errors::CertificateCircuitError;
+    use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
     use crate::circuits::key_generator::KeyGenerator;
     use crate::codec::{TryFromBytes, TryToBytes};
 
@@ -139,7 +248,7 @@ mod tests {
         )
         .expect("production verifying key bytes should deserialize");
 
-        // Exercises the `#[serde(with = "midnight_verifying_key_serde")]` serialize + deserialize path.
+        // Exercises the `#[serde(with = "certificate_verifying_key_serde")]` serialize + deserialize path.
         let json = serde_json::to_vec(&verifying_key).expect("serde serialize should succeed");
         let restored: NonRecursiveCircuitVerifyingKey =
             serde_json::from_slice(&json).expect("serde deserialize should succeed");
@@ -237,4 +346,114 @@ mod tests {
             "the already-sized SRS must be used directly, untouched"
         );
     }
+
+    // Both circuits encode their keys the same way, so only the declared architecture separates
+    // them: without the header check the recursive key would decode in the certificate position.
+    #[test]
+    fn a_recursive_verifying_key_is_rejected_in_the_certificate_position() {
+        let error = NonRecursiveCircuitVerifyingKey::try_from_bytes(
+            RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
+        )
+        .expect_err("a recursive key must not decode as a certificate one");
+
+        assert!(
+            matches!(
+                error.downcast_ref::<CertificateCircuitError>(),
+                Some(CertificateCircuitError::VerificationKeyArchitectureMismatch)
+            ),
+            "expected an architecture mismatch, got: {error}"
+        );
+    }
+
+    // `MidnightVK::read` derives its range bit length as `k - 1` on a byte, so a zero degree would
+    // underflow inside the dependency before any check of ours could run.
+    #[test]
+    fn a_zero_degree_header_is_rejected_before_it_can_underflow() {
+        let mut bytes = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec();
+        // The degree byte follows the encoded architecture.
+        let mut reader = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+        ZkStdLibArch::read_from_serialized_vk(&mut reader).expect("architecture should read");
+        let degree_index = bytes.len() - reader.len();
+        bytes[degree_index] = 0;
+
+        let error = NonRecursiveCircuitVerifyingKey::try_from_bytes(&bytes)
+            .expect_err("a zero degree must be rejected");
+
+        assert!(
+            matches!(
+                error.downcast_ref::<CertificateCircuitError>(),
+                Some(CertificateCircuitError::VerificationKeyDegreeMismatch { actual: 0, .. })
+            ),
+            "expected a degree mismatch, got: {error}"
+        );
+    }
+
+    // The envelope and the raw key it wraps each declare a degree, and the reader takes them
+    // independently, so an envelope declaring a supported degree can carry a raw key of another.
+    #[test]
+    fn a_wrapped_raw_key_of_another_degree_is_rejected() {
+        let mut bytes = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec();
+        // Past the architecture, the envelope degree and the public input count lies the raw key's
+        // own version byte, and its degree follows.
+        let mut reader = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+        ZkStdLibArch::read_from_serialized_vk(&mut reader).expect("architecture should read");
+        let envelope_degree_index = bytes.len() - reader.len();
+        let raw_degree_index = envelope_degree_index + 1 + 4 + 1;
+        // A degree the trusted setup could have produced, so only the disagreement is under test.
+        let other_degree = bytes[envelope_degree_index] - 1;
+        bytes[raw_degree_index] = other_degree;
+
+        let error = NonRecursiveCircuitVerifyingKey::try_from_bytes(&bytes)
+            .expect_err("a wrapped key of another degree must be rejected");
+
+        assert!(
+            matches!(
+                error.downcast_ref::<CertificateCircuitError>(),
+                Some(CertificateCircuitError::VerificationKeyDegreeMismatch { actual, .. })
+                    if *actual == u32::from(other_degree)
+            ),
+            "expected a degree mismatch, got: {error}"
+        );
+    }
+
+    // A key whose canonical re-serialization differs from the bytes it was decoded from would break
+    // every digest taken over an encoded key.
+    #[test]
+    fn an_encoding_with_trailing_bytes_is_rejected() {
+        let mut bytes = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec();
+        bytes.push(0);
+
+        let error = NonRecursiveCircuitVerifyingKey::try_from_bytes(&bytes)
+            .expect_err("trailing bytes must be rejected");
+
+        assert!(
+            matches!(
+                error.downcast_ref::<CertificateCircuitError>(),
+                Some(
+                    CertificateCircuitError::VerificationKeyEncodingHasTrailingBytes {
+                        trailing: 1
+                    }
+                )
+            ),
+            "expected a trailing-byte rejection, got: {error}"
+        );
+    }
+
+    // Deriving Deserialize would otherwise reach the dependency's reader without the guard, and
+    // that is the path the verifier data envelopes take.
+    #[test]
+    fn serde_rejects_a_recursive_verifying_key_in_the_certificate_position() {
+        let encoded = serde_json::to_vec(&serde_bytes::ByteBuf::from(
+            RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec(),
+        ))
+        .expect("the recursive key bytes should encode");
+
+        let error = serde_json::from_slice::<NonRecursiveCircuitVerifyingKey>(&encoded)
+            .expect_err("a recursive key must not deserialize as a certificate one");
+
+        assert!(
+            error.to_string().contains("architecture"),
+            "expected an architecture mismatch, got: {error}"
+        );
+    }
 }
diff --git a/mithril-stm/src/circuits/halo2_ivc/keys.rs b/mithril-stm/src/circuits/halo2_ivc/keys.rs
index 8c49b1920d4..2ba9e4cc152 100644
--- a/mithril-stm/src/circuits/halo2_ivc/keys.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/keys.rs
@@ -17,7 +17,6 @@ use crate::circuits::halo2::keys::NonRecursiveCircuitVerifyingKey;
 use crate::circuits::key_generator::KeyGenerator;
 use crate::circuits::key_provider::KeyProvider;
 use crate::circuits::key_serialization::KEY_SERDE_FORMAT;
-use crate::circuits::trusted_setup::MIDNIGHT_SRS_DEGREE;
 use crate::codec::{TryFromBytes, TryToBytes};
 
 use super::{
@@ -118,7 +117,7 @@ impl RecursiveCircuitVerifyingKey {
         let certificate_key = reader
             .get(..certificate_key_length)
             .ok_or_else(|| anyhow!("The relation's certificate key is truncated"))?;
-        validate_certificate_key_declared_degrees(certificate_key)?;
+        NonRecursiveCircuitVerifyingKey::validate_encoded_header(certificate_key)?;
         reader = &reader[certificate_key_length..];
 
         // The wrapped raw recursive key opens with its own version and degree.
@@ -273,54 +272,6 @@ impl TryFromBytes for RecursiveCircuitProvingKey {
     }
 }
 
-/// Rejects a certificate key whose declared degrees could not belong to any supported certificate
-/// circuit.
-///
-/// A certificate key is generated from the trusted setup, so it cannot exceed that setup's degree.
-///
-/// Certificate degrees legitimately vary — production, the full fixture and the small golden context
-/// all differ — so these are bounded rather than pinned. The key declares a degree twice, once in
-/// its Midnight envelope and once in the raw key it wraps, and the reader takes them independently:
-/// an envelope declaring a supported degree can wrap a raw key declaring any other, which reaches a
-/// domain constructor that asserts.
-fn validate_certificate_key_declared_degrees(certificate_key: &[u8]) -> StmResult<()> {
-    let mut reader = certificate_key;
-    ZkStdLibArch::read_from_serialized_vk(&mut reader)
-        .with_context(|| "Failed to read the certificate key architecture")?;
-
-    let mut envelope_degree = [0u8; 1];
-    reader
-        .read_exact(&mut envelope_degree)
-        .with_context(|| "Failed to read the certificate key envelope degree")?;
-
-    let mut public_input_count = [0u8; 4];
-    reader
-        .read_exact(&mut public_input_count)
-        .with_context(|| "Failed to read the certificate key public input count")?;
-
-    // The wrapped raw key opens with its own version and degree.
-    let mut raw_header = [0u8; 2];
-    reader
-        .read_exact(&mut raw_header)
-        .with_context(|| "Failed to read the wrapped raw certificate key header")?;
-
-    for degree in [envelope_degree[0], raw_header[1]] {
-        if degree == 0 || degree > MIDNIGHT_SRS_DEGREE {
-            return Err(anyhow!(IvcCircuitError::IvcVerificationKeyDegreeMismatch {
-                expected: u32::from(MIDNIGHT_SRS_DEGREE),
-                actual: u32::from(degree),
-            }));
-        }
-    }
-    if envelope_degree[0] != raw_header[1] {
-        return Err(anyhow!(IvcCircuitError::IvcVerificationKeyDegreeMismatch {
-            expected: u32::from(envelope_degree[0]),
-            actual: u32::from(raw_header[1]),
-        }));
-    }
-    Ok(())
-}
-
 impl KeyGenerator for IvcCircuit {
     type VerifyingKey = RecursiveCircuitVerifyingKey;
     type ProvingKey = RecursiveCircuitProvingKey;
@@ -397,6 +348,7 @@ impl KeyGenerator for RecursiveCircuitKeyGenerator {
 mod tests {
     use super::*;
     use crate::circuits::halo2::NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+    use crate::circuits::halo2::errors::CertificateCircuitError;
     use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
 
     #[test]
@@ -604,10 +556,11 @@ mod tests {
             Err(error) => error,
         };
 
+        // The certificate key is checked by the certificate newtype, so it reports its own error.
         assert!(
             matches!(
-                error.downcast_ref::<IvcCircuitError>(),
-                Some(IvcCircuitError::IvcVerificationKeyDegreeMismatch { actual: 32, .. })
+                error.downcast_ref::<CertificateCircuitError>(),
+                Some(CertificateCircuitError::VerificationKeyDegreeMismatch { actual: 32, .. })
             ),
             "expected a degree mismatch, got: {error}"
         );
diff --git a/mithril-stm/src/circuits/key_serialization.rs b/mithril-stm/src/circuits/key_serialization.rs
index ebc79bd0f9a..428653c9fd3 100644
--- a/mithril-stm/src/circuits/key_serialization.rs
+++ b/mithril-stm/src/circuits/key_serialization.rs
@@ -1,9 +1,13 @@
-//! Byte and serde encodings for a Midnight verifying key, shared by every circuit that stores its
-//! key in that format.
+//! Byte encoding of a Midnight verifying key, shared by every circuit that stores its key in that
+//! format.
 //!
 //! `MidnightVK` is self-describing and belongs to the standard library, so Rust coherence allows
 //! only one implementation of the crate's byte traits for it. It lives here rather than beside one
 //! circuit's keys so that both circuits reach the same encoding.
+//!
+//! Being self-describing is also why this codec cannot say which circuit a key belongs to: it
+//! decodes whatever the bytes declare. Each circuit's newtype guards its own decoder, and that is
+//! the entry point callers use.
 
 use anyhow::Context;
 use midnight_proofs::utils::SerdeFormat;
@@ -32,27 +36,3 @@ impl TryFromBytes for MidnightVK {
             .with_context(|| "Failed to deserialize the Midnight verifying key")
     }
 }
-
-/// Serde for a wrapped Midnight verifying key: delegates to the key's [`TryToBytes`] /
-/// [`TryFromBytes`] impl so the raw-bytes encoding is defined in one place.
-pub(crate) mod midnight_verifying_key_serde {
-    use midnight_zk_stdlib::MidnightVK;
-    use serde::{Deserializer, Serializer};
-
-    use crate::codec::{TryFromBytes, TryToBytes};
-
-    pub(crate) fn serialize<S: Serializer>(
-        verifying_key: &MidnightVK,
-        serializer: S,
-    ) -> Result<S::Ok, S::Error> {
-        let bytes = verifying_key.to_bytes_vec().map_err(serde::ser::Error::custom)?;
-        serializer.serialize_bytes(&bytes)
-    }
-
-    pub(crate) fn deserialize<'de, D: Deserializer<'de>>(
-        deserializer: D,
-    ) -> Result<MidnightVK, D::Error> {
-        let bytes: Vec<u8> = serde::Deserialize::deserialize(deserializer)?;
-        MidnightVK::try_from_bytes(&bytes).map_err(serde::de::Error::custom)
-    }
-}

From f80cf88006b10a2d538cebcfa67d4b90b1dd9b8b Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Fri, 18 Sep 2026 08:22:18 +0900
Subject: [PATCH 09/14] style(stm): group imports and hoist the ones inside
 functions

---
 mithril-stm/src/circuits/halo2_ivc/circuit.rs        |  5 +++--
 mithril-stm/src/circuits/halo2_ivc/keys.rs           |  6 ++----
 .../halo2_ivc/tests/common/failure_signature.rs      | 12 ++++++------
 .../halo2_ivc/tests/common/generators/proofs.rs      |  9 ++++-----
 .../halo2_ivc/tests/common/generators/setup.rs       |  2 +-
 .../src/circuits/halo2_ivc/tests/common/helpers.rs   |  7 +++----
 .../circuits/halo2_ivc/tests/encoding/positive.rs    | 10 ++++------
 .../proof_system/halo2_ivc_snark/verifier_setup.rs   |  5 ++---
 8 files changed, 25 insertions(+), 31 deletions(-)

diff --git a/mithril-stm/src/circuits/halo2_ivc/circuit.rs b/mithril-stm/src/circuits/halo2_ivc/circuit.rs
index 4cf8e029e19..eb433fffcad 100644
--- a/mithril-stm/src/circuits/halo2_ivc/circuit.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/circuit.rs
@@ -1,7 +1,9 @@
+use anyhow::anyhow;
+
 use crate::StmResult;
 use crate::circuits::halo2::keys::NonRecursiveCircuitVerifyingKey;
 use crate::circuits::halo2_ivc::keys::RecursiveCircuitVerifyingKey;
-use anyhow::anyhow;
+use crate::codec::{TryFromBytes, TryToBytes};
 
 use super::{
     Accumulator, BinaryInstructions, CircuitValue, ConstraintSystem, Error, EvaluationDomain,
@@ -13,7 +15,6 @@ use super::{
     types::{CertificateProofBytes, IvcProofBytes},
     witness_assignments,
 };
-use crate::codec::{TryFromBytes, TryToBytes};
 
 /// Chips the recursive circuit enables.
 ///
diff --git a/mithril-stm/src/circuits/halo2_ivc/keys.rs b/mithril-stm/src/circuits/halo2_ivc/keys.rs
index 2ba9e4cc152..28bff3459c4 100644
--- a/mithril-stm/src/circuits/halo2_ivc/keys.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/keys.rs
@@ -346,6 +346,8 @@ impl KeyGenerator for RecursiveCircuitKeyGenerator {
 
 #[cfg(test)]
 mod tests {
+    use midnight_proofs::utils::helpers::byte_length;
+
     use super::*;
     use crate::circuits::halo2::NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
     use crate::circuits::halo2::errors::CertificateCircuitError;
@@ -492,8 +494,6 @@ mod tests {
     // declare fewer than the configured constraint system has columns.
     #[test]
     fn a_key_declaring_too_few_fixed_commitments_is_rejected() {
-        use midnight_proofs::utils::helpers::byte_length;
-
         let mut reader = RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
         ZkStdLibArch::read_from_serialized_vk(&mut reader).expect("architecture should read");
         // envelope degree, public input count, then the raw key's version and degree
@@ -536,8 +536,6 @@ mod tests {
     // independently, so a supported envelope can wrap a raw key of any other degree.
     #[test]
     fn a_proving_key_whose_certificate_inner_degree_disagrees_is_rejected() {
-        use crate::circuits::halo2::NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
-
         let mut certificate_key = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec();
         let mut reader = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
         ZkStdLibArch::read_from_serialized_vk(&mut reader).expect("architecture should read");
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/failure_signature.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/failure_signature.rs
index 2dae7161128..9362fbf2a35 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/failure_signature.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/failure_signature.rs
@@ -5,19 +5,19 @@
 //! Advice-side members of a broken class are not enumerated: their columns and regions are named by
 //! the gadget layer and carry no stability guarantee.
 
-use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_DEGREE;
-use crate::circuits::halo2_ivc::circuit::IvcCircuit;
-use midnight_proofs::circuit::Value;
-use midnight_zk_stdlib::MidnightCircuit;
-
 use std::collections::{BTreeMap, BTreeSet};
 
+use midnight_proofs::circuit::Value;
 use midnight_proofs::{
     dev::{FailureLocation, MockProver, VerifyFailure},
     plonk::{Any, Circuit},
 };
+use midnight_zk_stdlib::MidnightCircuit;
 
-use crate::circuits::halo2_ivc::{NativeField, circuit::IvcCircuitData};
+use crate::circuits::halo2_ivc::{
+    NativeField, RECURSIVE_CIRCUIT_DEGREE,
+    circuit::{IvcCircuit, IvcCircuitData},
+};
 
 /// Index of the instance column carrying the circuit's public statement.
 ///
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs
index cb2a662c69e..024a7b9430e 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/proofs.rs
@@ -1,13 +1,10 @@
-use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_DEGREE;
-use crate::circuits::halo2_ivc::circuit::IvcCircuit;
-use midnight_proofs::circuit::Value;
-use midnight_zk_stdlib::MidnightCircuit;
 use std::hash::Hash;
 
 use ff::FromUniformBytes;
 use group::Group;
 use midnight_circuits::hash::poseidon::PoseidonState;
 use midnight_curves::Bls12;
+use midnight_proofs::circuit::Value;
 use midnight_proofs::{
     plonk::{create_proof, prepare},
     poly::{
@@ -16,11 +13,13 @@ use midnight_proofs::{
     },
     transcript::{Blake2b256, CircuitTranscript, Hashable, Sampleable, Transcript, TranscriptHash},
 };
+use midnight_zk_stdlib::MidnightCircuit;
 use rand_core::{CryptoRng, RngCore};
 
 use crate::circuits::halo2_ivc::keys::RecursiveCircuitProvingKey;
 use crate::circuits::halo2_ivc::{
-    EmulatedCurve, NativeField, PairingEngine, VerifyingKey, circuit::IvcCircuitData,
+    EmulatedCurve, NativeField, PairingEngine, RECURSIVE_CIRCUIT_DEGREE, VerifyingKey,
+    circuit::{IvcCircuit, IvcCircuitData},
 };
 
 /// Generates a recursive proof using the chosen transcript hash.
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs
index 144cb33c632..61d6f54d047 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/generators/setup.rs
@@ -1,4 +1,3 @@
-use midnight_zk_stdlib::{self as zk};
 use std::{
     collections::BTreeMap,
     io::Write,
@@ -9,6 +8,7 @@ use ff::Field;
 use midnight_curves::Bls12;
 use midnight_proofs::poly::kzg::params::{ParamsKZG, ParamsVerifierKZG};
 use midnight_zk_stdlib as zk_lib;
+use midnight_zk_stdlib::{self as zk};
 use rand_chacha::ChaCha20Rng;
 use rand_core::{CryptoRng, RngCore, SeedableRng};
 use serde::{Deserialize, Serialize};
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/common/helpers.rs b/mithril-stm/src/circuits/halo2_ivc/tests/common/helpers.rs
index f58351e31ea..c93387a4e72 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/common/helpers.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/common/helpers.rs
@@ -1,18 +1,17 @@
-use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_DEGREE;
-use midnight_proofs::circuit::Value;
-use midnight_zk_stdlib::MidnightCircuit;
 use std::collections::BTreeMap;
 
 use midnight_circuits::types::Instantiable;
 use midnight_curves::Bls12;
+use midnight_proofs::circuit::Value;
 use midnight_proofs::{
     dev::MockProver,
     poly::kzg::params::{ParamsKZG, ParamsVerifierKZG},
 };
+use midnight_zk_stdlib::MidnightCircuit;
 
 use crate::circuits::halo2_ivc::{
     Accumulator, AssignedAccumulator, EmulatedCurve, NativeField, PREIMAGE_SIZE, PairingEngine,
-    RecursiveEmulation,
+    RECURSIVE_CIRCUIT_DEGREE, RecursiveEmulation,
     accumulator::trivial_accumulator,
     circuit::{IvcCircuit, IvcCircuitData},
     state::{Global, State, Witness},
diff --git a/mithril-stm/src/circuits/halo2_ivc/tests/encoding/positive.rs b/mithril-stm/src/circuits/halo2_ivc/tests/encoding/positive.rs
index 9bec8499822..b84ba086f93 100644
--- a/mithril-stm/src/circuits/halo2_ivc/tests/encoding/positive.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/tests/encoding/positive.rs
@@ -1,20 +1,18 @@
 //! Positive encoding tests: preimage layout, state public input format, and
 //! serialization round-trips.
 
-use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_DEGREE;
-use crate::circuits::halo2_ivc::circuit::IvcCircuit;
-use crate::circuits::halo2_ivc::circuit::recursive_circuit_architecture;
-use midnight_zk_stdlib::MidnightCircuit;
-
 use ff::Field;
 use midnight_proofs::utils::SerdeFormat;
+use midnight_zk_stdlib::MidnightCircuit;
 use proptest::prelude::*;
 use sha2::{Digest as Sha2Digest, Sha256};
 
 use crate::circuits::halo2_ivc::{
     Accumulator, KZGCommitmentScheme, NativeField, PREIMAGE_CURRENT_EPOCH_BYTES,
     PREIMAGE_NEXT_MERKLE_TREE_COMMITMENT_BYTES, PREIMAGE_NEXT_PROTOCOL_PARAMETERS_BYTES,
-    PREIMAGE_SIZE, PairingEngine, ProtocolMessagePreimage, RecursiveEmulation, VerifyingKey,
+    PREIMAGE_SIZE, PairingEngine, ProtocolMessagePreimage, RECURSIVE_CIRCUIT_DEGREE,
+    RecursiveEmulation, VerifyingKey,
+    circuit::{IvcCircuit, recursive_circuit_architecture},
     io::{ReadWithFormat, WriteWithFormat},
     protocol_message::{DynamicProtocolMessagePartKey, ProtocolMessage},
     state::State,
diff --git a/mithril-stm/src/proof_system/halo2_ivc_snark/verifier_setup.rs b/mithril-stm/src/proof_system/halo2_ivc_snark/verifier_setup.rs
index 315d11774f6..d18c49b5275 100644
--- a/mithril-stm/src/proof_system/halo2_ivc_snark/verifier_setup.rs
+++ b/mithril-stm/src/proof_system/halo2_ivc_snark/verifier_setup.rs
@@ -219,6 +219,8 @@ impl IvcVerifierData {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::circuits::halo2::NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+    use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
     use crate::{
         BaseFieldElement,
         circuits::{
@@ -335,9 +337,6 @@ mod tests {
     // is the path a certificate carries, and the two circuits now share one key encoding.
     #[test]
     fn verifier_data_rejects_a_certificate_key_in_the_recursive_position() {
-        use crate::circuits::halo2::NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
-        use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
-
         // Mirrors `IvcVerifierData`'s CBOR shape with both keys as opaque bytes, so the recursive
         // slot can carry an encoding the typed constructor would never allow.
         #[derive(serde::Serialize)]

From dd14e3bd131018d79c08d87fa0d6b61ec80e9d6f Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Fri, 18 Sep 2026 08:40:33 +0900
Subject: [PATCH 10/14] test(stm): decode the cached keys through their typed
 decoders

---
 .../halo2_ivc_snark/prover_setup.rs           | 109 +++++++++++++++---
 1 file changed, 90 insertions(+), 19 deletions(-)

diff --git a/mithril-stm/src/proof_system/halo2_ivc_snark/prover_setup.rs b/mithril-stm/src/proof_system/halo2_ivc_snark/prover_setup.rs
index e6b61a23e3a..4539c6a5eac 100644
--- a/mithril-stm/src/proof_system/halo2_ivc_snark/prover_setup.rs
+++ b/mithril-stm/src/proof_system/halo2_ivc_snark/prover_setup.rs
@@ -157,6 +157,24 @@ impl IvcProverSetup {
         Self::build_for_test_degree(parameters, merkle_tree_depth, RECURSIVE_CIRCUIT_DEGREE)
     }
 
+    /// The shared cache the test setup derives its keys in.
+    ///
+    /// Defined once so a test can locate the cache without restating the inputs its identity is
+    /// built from.
+    #[cfg(test)]
+    fn test_key_cache(parameters_bytes: &[u8], depth_bytes: &[u8], seed_bytes: &[u8]) -> FileMutex {
+        FileMutex::for_shared_cache(
+            "ivc-setup",
+            &[
+                NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
+                RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
+                parameters_bytes,
+                depth_bytes,
+                seed_bytes,
+            ],
+        )
+    }
+
     /// Builds an [`IvcProverSetup`] from a deterministic unsafe SRS with degree determined by the input
     /// `unsafe_srs_degree`.
     /// Uses a cache for the unsafe SRS to avoid regenerating it when a SRS of the correct degree already exists
@@ -178,16 +196,7 @@ impl IvcProverSetup {
         let trusted_setup_provider =
             TrustedSetupProvider::with_unsafe_srs(&srs_directory, unsafe_srs_degree);
 
-        let key_cache = FileMutex::for_shared_cache(
-            "ivc-setup",
-            &[
-                NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
-                RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
-                &parameters_bytes,
-                &depth_bytes,
-                &seed_bytes,
-            ],
-        );
+        let key_cache = Self::test_key_cache(&parameters_bytes, &depth_bytes, &seed_bytes);
         let cache_directory = key_cache.directory().to_path_buf();
         // Serialize cold-start keygen across the parallel slow-test processes.
         let _key_cache_lock = key_cache.lock()?;
@@ -364,27 +373,30 @@ mod tests {
     }
 
     mod slow {
+        use std::path::Path;
+
         use midnight_proofs::poly::commitment::Params;
 
+        use crate::circuits::halo2::keys::NonRecursiveCircuitProvingKey;
         use crate::circuits::halo2_ivc::tests::common::{
             asset_readers::load_embedded_verification_context_asset,
             generators::setup::{QUORUM_SIZE, SIGNER_COUNT},
         };
+        use crate::codec::TryFromBytes;
 
         use super::*;
 
         // Runs the real `load` path against an oversized unsafe SRS; runs in the `slow` tier.
         #[test]
         fn load_succeeds_with_unsafe_srs() {
-            let setup = IvcProverSetup::build_for_test(
-                &Parameters {
-                    k: 3,
-                    m: 10,
-                    phi_f: 0.2,
-                },
-                4,
-            )
-            .expect("IvcProverSetup::build_for_test should succeed");
+            let parameters = Parameters {
+                k: 3,
+                m: 10,
+                phi_f: 0.2,
+            };
+            let merkle_tree_depth = 4;
+            let setup = IvcProverSetup::build_for_test(&parameters, merkle_tree_depth)
+                .expect("IvcProverSetup::build_for_test should succeed");
 
             assert!(
                 !setup.certificate_fixed_bases.is_empty(),
@@ -409,6 +421,65 @@ mod tests {
                     "combined map should preserve every IVC base"
                 );
             }
+
+            // A cold run generates the keys, writes them and keeps the generated ones, so it never
+            // decodes what it wrote; no other slow test shares this configuration's cache. Without
+            // this, the recursive proving-key decoder would only ever see malformed bytes, being
+            // the one key type with no valid-key round-trip test of its own. The generated keys are
+            // dropped first so the recursive pair, a gigabyte on disk, is never held twice.
+            let key_cache = IvcProverSetup::test_key_cache(
+                &parameters.to_bytes().expect("parameters should encode"),
+                &merkle_tree_depth.to_le_bytes(),
+                &UNSAFE_SRS_SEED.to_le_bytes(),
+            );
+            let certificate_directory = key_cache.directory().join("certificate");
+            let recursive_directory = key_cache.directory().join("recursive");
+            drop(setup);
+
+            NonRecursiveCircuitVerifyingKey::try_from_bytes(&read_cached_key(
+                &certificate_directory,
+                "verification-key",
+            ))
+            .expect("the cached certificate verifying key must decode");
+            NonRecursiveCircuitProvingKey::try_from_bytes(&read_cached_key(
+                &certificate_directory,
+                "proving-key",
+            ))
+            .expect("the cached certificate proving key must decode");
+            RecursiveCircuitVerifyingKey::try_from_bytes(&read_cached_key(
+                &recursive_directory,
+                "verification-key",
+            ))
+            .expect("the cached recursive verifying key must decode");
+            RecursiveCircuitProvingKey::try_from_bytes(&read_cached_key(
+                &recursive_directory,
+                "proving-key",
+            ))
+            .expect("the cached recursive proving key must decode");
+        }
+
+        /// Reads the one cached key of the given name beneath `directory`, whose layout belongs to
+        /// the key provider rather than to this test.
+        fn read_cached_key(directory: &Path, name: &str) -> Vec<u8> {
+            let mut found = Vec::new();
+            let mut pending = vec![directory.to_path_buf()];
+            while let Some(current) = pending.pop() {
+                for entry in std::fs::read_dir(&current).into_iter().flatten().flatten() {
+                    let path = entry.path();
+                    if path.is_dir() {
+                        pending.push(path);
+                    } else if path.file_name().and_then(|file| file.to_str()) == Some(name) {
+                        found.push(path);
+                    }
+                }
+            }
+            assert_eq!(
+                found.len(),
+                1,
+                "exactly one {name} should be cached under {}, found: {found:?}",
+                directory.display()
+            );
+            std::fs::read(&found[0]).expect("a cached key should be readable")
         }
 
         // `IvcProverSetup::build_for_test` loads from an oversized unsafe SRS that shares the production

From d6d8defd08d7829e2956ef85792fab60c93294b8 Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Fri, 18 Sep 2026 08:50:18 +0900
Subject: [PATCH 11/14] fix(stm): reject trailing bytes after a recursive
 proving key

---
 mithril-stm/src/circuits/halo2_ivc/keys.rs    | 17 +++++++++---
 .../halo2_ivc_snark/prover_setup.rs           | 26 +++++++++++++++----
 2 files changed, 34 insertions(+), 9 deletions(-)

diff --git a/mithril-stm/src/circuits/halo2_ivc/keys.rs b/mithril-stm/src/circuits/halo2_ivc/keys.rs
index 28bff3459c4..6467b2186e9 100644
--- a/mithril-stm/src/circuits/halo2_ivc/keys.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/keys.rs
@@ -265,10 +265,19 @@ impl TryFromBytes for RecursiveCircuitProvingKey {
         RecursiveCircuitVerifyingKey::validate_encoded_proving_key_header(bytes)?;
 
         let mut reader = bytes;
-        Ok(Self(
-            MidnightPK::<IvcCircuit>::read(&mut reader, KEY_SERDE_FORMAT)
-                .with_context(|| "Failed to deserialize the recursive proving key")?,
-        ))
+        let midnight_pk = MidnightPK::<IvcCircuit>::read(&mut reader, KEY_SERDE_FORMAT)
+            .with_context(|| "Failed to deserialize the recursive proving key")?;
+        // A cache entry holds one key and nothing else, the same rule the verifying key decoder
+        // above applies.
+        if !reader.is_empty() {
+            return Err(anyhow!(
+                IvcCircuitError::RecursiveKeyEncodingHasTrailingBytes {
+                    trailing: reader.len(),
+                }
+            ));
+        }
+
+        Ok(Self(midnight_pk))
     }
 }
 
diff --git a/mithril-stm/src/proof_system/halo2_ivc_snark/prover_setup.rs b/mithril-stm/src/proof_system/halo2_ivc_snark/prover_setup.rs
index 4539c6a5eac..263bbe6cd98 100644
--- a/mithril-stm/src/proof_system/halo2_ivc_snark/prover_setup.rs
+++ b/mithril-stm/src/proof_system/halo2_ivc_snark/prover_setup.rs
@@ -378,6 +378,7 @@ mod tests {
         use midnight_proofs::poly::commitment::Params;
 
         use crate::circuits::halo2::keys::NonRecursiveCircuitProvingKey;
+        use crate::circuits::halo2_ivc::errors::IvcCircuitError;
         use crate::circuits::halo2_ivc::tests::common::{
             asset_readers::load_embedded_verification_context_asset,
             generators::setup::{QUORUM_SIZE, SIGNER_COUNT},
@@ -451,11 +452,26 @@ mod tests {
                 "verification-key",
             ))
             .expect("the cached recursive verifying key must decode");
-            RecursiveCircuitProvingKey::try_from_bytes(&read_cached_key(
-                &recursive_directory,
-                "proving-key",
-            ))
-            .expect("the cached recursive proving key must decode");
+            let mut recursive_proving_key_bytes =
+                read_cached_key(&recursive_directory, "proving-key");
+            RecursiveCircuitProvingKey::try_from_bytes(&recursive_proving_key_bytes)
+                .expect("the cached recursive proving key must decode");
+
+            // Only a valid encoding can exercise the decoder's full-consumption rule, and this is
+            // the one place a valid recursive proving key exists.
+            recursive_proving_key_bytes.push(0);
+            let error =
+                match RecursiveCircuitProvingKey::try_from_bytes(&recursive_proving_key_bytes) {
+                    Ok(_) => panic!("a recursive proving key with trailing bytes must be rejected"),
+                    Err(error) => error,
+                };
+            assert!(
+                matches!(
+                    error.downcast_ref::<IvcCircuitError>(),
+                    Some(IvcCircuitError::RecursiveKeyEncodingHasTrailingBytes { trailing: 1 })
+                ),
+                "expected a trailing-byte rejection, got: {error}"
+            );
         }
 
         /// Reads the one cached key of the given name beneath `directory`, whose layout belongs to

From d3037e76ff3b1a200dd5ac142f4f04b24d4e5735 Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Fri, 18 Sep 2026 09:56:09 +0900
Subject: [PATCH 12/14] fix(stm): check the certificate key commitment count
 and remove the unguarded decoder

---
 mithril-stm/src/circuits/halo2/errors.rs      |  7 ++
 .../src/circuits/halo2/key_serialization.rs   | 10 ++-
 mithril-stm/src/circuits/halo2/keys.rs        | 86 ++++++++++++++++++-
 mithril-stm/src/circuits/key_serialization.rs | 18 ++--
 4 files changed, 101 insertions(+), 20 deletions(-)

diff --git a/mithril-stm/src/circuits/halo2/errors.rs b/mithril-stm/src/circuits/halo2/errors.rs
index fe5b6644921..d09e390476f 100644
--- a/mithril-stm/src/circuits/halo2/errors.rs
+++ b/mithril-stm/src/circuits/halo2/errors.rs
@@ -128,6 +128,13 @@ pub enum CertificateCircuitError {
     /// A standalone encoded verification key is followed by bytes that are not part of it.
     #[error("The encoded certificate verification key has {trailing} trailing byte(s)")]
     VerificationKeyEncodingHasTrailingBytes { trailing: usize },
+
+    /// An encoded verification key declares fewer fixed commitments than its constraint system has
+    /// fixed columns, which the verifier indexes by column.
+    #[error(
+        "Certificate verification key fixed commitment count mismatch: expected {expected}, got {actual}"
+    )]
+    VerificationKeyCommitmentCountMismatch { expected: usize, actual: usize },
 }
 
 impl From<PlonkError> for CertificateCircuitError {
diff --git a/mithril-stm/src/circuits/halo2/key_serialization.rs b/mithril-stm/src/circuits/halo2/key_serialization.rs
index a4da211a870..37d6cde4f86 100644
--- a/mithril-stm/src/circuits/halo2/key_serialization.rs
+++ b/mithril-stm/src/circuits/halo2/key_serialization.rs
@@ -31,19 +31,21 @@ impl TryFromBytes for MidnightPK<CertificateCircuit> {
 #[cfg(test)]
 mod tests {
     use midnight_proofs::poly::kzg::params::ParamsKZG;
-    use midnight_zk_stdlib::{self as zk, MidnightCircuit, MidnightVK};
+    use midnight_zk_stdlib::{self as zk, MidnightCircuit};
     use rand_chacha::ChaCha20Rng;
     use rand_core::SeedableRng;
 
     use super::*;
     use crate::Parameters;
     use crate::circuits::halo2::NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+    use crate::circuits::halo2::keys::NonRecursiveCircuitVerifyingKey;
 
     #[test]
     fn production_verifying_key_serializes_to_the_embedded_bytes() {
-        let verifying_key =
-            MidnightVK::try_from_bytes(NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION)
-                .expect("production verifying key bytes should deserialize");
+        let verifying_key = NonRecursiveCircuitVerifyingKey::try_from_bytes(
+            NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
+        )
+        .expect("production verifying key bytes should deserialize");
         assert_eq!(
             verifying_key.to_bytes_vec().expect("serialize should succeed"),
             NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
diff --git a/mithril-stm/src/circuits/halo2/keys.rs b/mithril-stm/src/circuits/halo2/keys.rs
index 20d49331594..8326b41976a 100644
--- a/mithril-stm/src/circuits/halo2/keys.rs
+++ b/mithril-stm/src/circuits/halo2/keys.rs
@@ -8,12 +8,16 @@ use anyhow::{Context, anyhow};
 use midnight_curves::Bls12;
 use midnight_proofs::poly::commitment::Params;
 use midnight_proofs::poly::kzg::params::ParamsKZG;
-use midnight_zk_stdlib::{self as zk, MidnightCircuit, MidnightPK, MidnightVK, ZkStdLibArch};
+use midnight_zk_stdlib::{
+    self as zk, MidnightCircuit, MidnightPK, MidnightVK, ZkStdLib, ZkStdLibArch,
+};
 use serde::{Deserialize, Serialize};
 
 use crate::StmResult;
 use crate::circuits::halo2::errors::CertificateCircuitError;
-use crate::circuits::halo2_ivc::{KZGCommitmentScheme, NativeField, PairingEngine, VerifyingKey};
+use crate::circuits::halo2_ivc::{
+    ConstraintSystem, KZGCommitmentScheme, NativeField, PairingEngine, VerifyingKey,
+};
 use crate::circuits::key_generator::KeyGenerator;
 use crate::circuits::key_serialization::KEY_SERDE_FORMAT;
 use crate::circuits::trusted_setup::MIDNIGHT_SRS_DEGREE;
@@ -48,6 +52,21 @@ impl NonRecursiveCircuitVerifyingKey {
         self.midnight_vk().vk().get_domain().k()
     }
 
+    /// Number of fixed commitments the approved architecture produces at `degree`.
+    ///
+    /// The reader takes this count from the bytes and reads that many commitments, so a key can
+    /// declare fewer than the configured constraint system has columns; later verification indexes
+    /// commitments by those columns. The degree comes from the key because certificate degrees vary.
+    fn expected_fixed_commitment_count(degree: u32) -> usize {
+        let mut constraint_system = ConstraintSystem::<NativeField>::default();
+        ZkStdLib::configure(
+            &mut constraint_system,
+            (certificate_circuit_architecture(), (degree - 1) as u8),
+        );
+        // Selectors become fixed columns when the key is read.
+        constraint_system.num_fixed_columns() + constraint_system.num_selectors()
+    }
+
     /// Checks the header of an encoded certificate verifying key before it is decoded.
     ///
     /// `MidnightVK` takes its architecture and degree from the bytes, so without this any Midnight
@@ -172,6 +191,17 @@ impl TryFromBytes for NonRecursiveCircuitVerifyingKey {
             ));
         }
 
+        let actual = midnight_vk.vk().fixed_commitments().len();
+        let expected = Self::expected_fixed_commitment_count(midnight_vk.vk().get_domain().k());
+        if actual != expected {
+            return Err(anyhow!(
+                CertificateCircuitError::VerificationKeyCommitmentCountMismatch {
+                    expected,
+                    actual
+                }
+            ));
+        }
+
         Ok(Self(midnight_vk))
     }
 }
@@ -229,6 +259,8 @@ mod tests {
     use rand_chacha::ChaCha20Rng;
     use rand_core::SeedableRng;
 
+    use midnight_proofs::poly::commitment::PolynomialCommitmentScheme;
+    use midnight_proofs::utils::helpers::byte_length;
     use midnight_zk_stdlib::ZkStdLibArch;
 
     use super::{NonRecursiveCircuitProvingKey, NonRecursiveCircuitVerifyingKey};
@@ -236,8 +268,12 @@ mod tests {
     use crate::circuits::halo2::NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
     use crate::circuits::halo2::circuit::CertificateCircuit;
     use crate::circuits::halo2::errors::CertificateCircuitError;
-    use crate::circuits::halo2_ivc::RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+    use crate::circuits::halo2_ivc::{
+        KZGCommitmentScheme, NativeField, PairingEngine,
+        RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION,
+    };
     use crate::circuits::key_generator::KeyGenerator;
+    use crate::circuits::key_serialization::KEY_SERDE_FORMAT;
     use crate::codec::{TryFromBytes, TryToBytes};
 
     #[test]
@@ -456,4 +492,48 @@ mod tests {
             "expected an architecture mismatch, got: {error}"
         );
     }
+
+    // The reader takes the commitment count from the bytes and reads that many, so a key can declare
+    // fewer than its constraint system has fixed columns; verification then indexes by column.
+    #[test]
+    fn a_key_declaring_too_few_fixed_commitments_is_rejected() {
+        let mut reader = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION;
+        ZkStdLibArch::read_from_serialized_vk(&mut reader).expect("architecture should read");
+        let base = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.len() - reader.len();
+        // envelope degree, public input count, then the raw key's version and degree
+        let count_index = base + 1 + 4 + 2;
+
+        let mut bytes = NON_RECURSIVE_CIRCUIT_VERIFICATION_KEY_FOR_PRODUCTION.to_vec();
+        let declared = u32::from_le_bytes(bytes[count_index..count_index + 4].try_into().unwrap());
+        assert_eq!(
+            declared as usize,
+            NonRecursiveCircuitVerifyingKey::expected_fixed_commitment_count(u32::from(
+                bytes[base]
+            )),
+            "the production key should declare the configured commitment count"
+        );
+
+        // Drop one commitment along with the count, so the encoding stays internally consistent and
+        // fully consumed: only the cardinality guard can reject it.
+        let commitment_length = byte_length::<
+            <KZGCommitmentScheme<PairingEngine> as PolynomialCommitmentScheme<NativeField>>::Commitment,
+        >(KEY_SERDE_FORMAT);
+        let commitments_start = count_index + 4;
+        bytes.drain(commitments_start..commitments_start + commitment_length);
+        bytes[count_index..count_index + 4].copy_from_slice(&(declared - 1).to_le_bytes());
+
+        let error = NonRecursiveCircuitVerifyingKey::try_from_bytes(&bytes)
+            .expect_err("a short commitment count must be rejected");
+
+        assert!(
+            matches!(
+                error.downcast_ref::<CertificateCircuitError>(),
+                Some(CertificateCircuitError::VerificationKeyCommitmentCountMismatch {
+                    actual,
+                    ..
+                }) if *actual as u32 == declared - 1
+            ),
+            "expected a commitment count mismatch, got: {error}"
+        );
+    }
 }
diff --git a/mithril-stm/src/circuits/key_serialization.rs b/mithril-stm/src/circuits/key_serialization.rs
index 428653c9fd3..5c67886192b 100644
--- a/mithril-stm/src/circuits/key_serialization.rs
+++ b/mithril-stm/src/circuits/key_serialization.rs
@@ -5,21 +5,21 @@
 //! only one implementation of the crate's byte traits for it. It lives here rather than beside one
 //! circuit's keys so that both circuits reach the same encoding.
 //!
-//! Being self-describing is also why this codec cannot say which circuit a key belongs to: it
-//! decodes whatever the bytes declare. Each circuit's newtype guards its own decoder, and that is
-//! the entry point callers use.
+//! Only the encoding direction lives here. Being self-describing means a decoder cannot tell which
+//! circuit a key belongs to — it decodes whatever the bytes declare — so decoding belongs to each
+//! circuit's newtype, behind that circuit's guard, and there is deliberately no unguarded decoder to
+//! reach for.
 
 use anyhow::Context;
 use midnight_proofs::utils::SerdeFormat;
 use midnight_zk_stdlib::MidnightVK;
 
 use crate::StmResult;
-use crate::codec::{TryFromBytes, TryToBytes};
+use crate::codec::TryToBytes;
 
 /// Serde format used for the on-disk / in-cache production keys.
 pub(crate) const KEY_SERDE_FORMAT: SerdeFormat = SerdeFormat::RawBytes;
 
-// `MidnightVK` is self-describing, so reading needs only the serde format, no circuit type.
 impl TryToBytes for MidnightVK {
     fn to_bytes_vec(&self) -> StmResult<Vec<u8>> {
         let mut bytes = Vec::new();
@@ -28,11 +28,3 @@ impl TryToBytes for MidnightVK {
         Ok(bytes)
     }
 }
-
-impl TryFromBytes for MidnightVK {
-    fn try_from_bytes(bytes: &[u8]) -> StmResult<Self> {
-        let mut reader = bytes;
-        MidnightVK::read(&mut reader, KEY_SERDE_FORMAT)
-            .with_context(|| "Failed to deserialize the Midnight verifying key")
-    }
-}

From b84ba47391802474e542461ee22b31a968be58a3 Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Mon, 21 Sep 2026 14:55:44 +0900
Subject: [PATCH 13/14] perf(stm): borrow the witness instead of cloning it
 once per field

---
 mithril-stm/src/circuits/halo2_ivc/circuit.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/mithril-stm/src/circuits/halo2_ivc/circuit.rs b/mithril-stm/src/circuits/halo2_ivc/circuit.rs
index eb433fffcad..9e174ebb8f3 100644
--- a/mithril-stm/src/circuits/halo2_ivc/circuit.rs
+++ b/mithril-stm/src/circuits/halo2_ivc/circuit.rs
@@ -135,12 +135,14 @@ impl Relation for IvcCircuit {
     ) -> Result<(), Error> {
         let builder = IvcConstraintBuilder::new(std_lib);
 
-        let global_value = witness.clone().map(|data| data.global);
-        let state_value = witness.clone().map(|data| data.state);
-        let witness_value = witness.clone().map(|data| data.witness);
-        let certificate_proof_value = witness.clone().map(|data| data.certificate_proof);
-        let ivc_proof_value = witness.clone().map(|data| data.ivc_proof);
-        let accumulator_value = witness.map(|data| data.accumulator);
+        // Borrowed, so each part is copied once rather than the whole witness copied once per part.
+        let data = witness.as_ref();
+        let global_value = data.map(|data| data.global.clone());
+        let state_value = data.map(|data| data.state.clone());
+        let witness_value = data.map(|data| data.witness.clone());
+        let certificate_proof_value = data.map(|data| data.certificate_proof.clone());
+        let ivc_proof_value = data.map(|data| data.ivc_proof.clone());
+        let accumulator_value = data.map(|data| data.accumulator.clone());
 
         let (ivc_circuit_domain, ivc_circuit_constraint_system) =
             &self.ivc_circuit_domain_and_constraint_system;

From 24eaa1dbe7fd5260987004c688ecd6cba56da8ac Mon Sep 17 00:00:00 2001
From: Hamza Jeljeli <hamza.jeljeli@iohk.io>
Date: Mon, 21 Sep 2026 14:57:51 +0900
Subject: [PATCH 14/14] chore(stm): update the changelog and the crate version

---
 Cargo.lock                |  2 +-
 mithril-common/Cargo.toml |  2 +-
 mithril-stm/CHANGELOG.md  | 18 ++++++++++++++++++
 mithril-stm/Cargo.toml    |  2 +-
 4 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 904f183d223..9ae07e98a7b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4834,7 +4834,7 @@ dependencies = [
 
 [[package]]
 name = "mithril-stm"
-version = "0.12.19"
+version = "0.12.20"
 dependencies = [
  "anyhow",
  "blake2 0.10.6",
diff --git a/mithril-common/Cargo.toml b/mithril-common/Cargo.toml
index 5c66a49831f..c36a05a776c 100644
--- a/mithril-common/Cargo.toml
+++ b/mithril-common/Cargo.toml
@@ -51,7 +51,7 @@ fixed = "1.31.0"
 hex = { workspace = true }
 kes-summed-ed25519 = { version = "0.2.1", features = ["serde_enabled", "sk_clone_enabled"] }
 mithril-merkle-tree = { path = "../internal/mithril-merkle-tree", version = "0.1.4" }
-mithril-stm = { path = "../mithril-stm", version = "0.12.19", default-features = false }
+mithril-stm = { path = "../mithril-stm", version = "0.12.20", default-features = false }
 nom = "8.0.0"
 rand_chacha = { workspace = true }
 rand_core = { workspace = true }
diff --git a/mithril-stm/CHANGELOG.md b/mithril-stm/CHANGELOG.md
index 927fd337477..f6c7f26a881 100644
--- a/mithril-stm/CHANGELOG.md
+++ b/mithril-stm/CHANGELOG.md
@@ -5,6 +5,24 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.12.20 (09-21-2026)
+
+### Changed
+
+- Moved the IVC circuit onto the Midnight standard library's `Relation` trait, replacing the hand-written configuration. The statement and the degree are unchanged, but the standard library registers gates in a different order, so the recursive verifying key moves: a breaking circuit key change requiring a re-genesis, with every derived asset regenerated.
+- Encoded the recursive circuit keys in the certificate keys' format, through one shared codec. The inner key is byte-identical, so this adds a 23-byte envelope without altering circuit identity.
+- Bound the recursive key into the recursive circuit's cache identity, non-production entries having been fingerprinted from the certificate key alone.
+- Borrowed the witness during synthesis instead of copying it once per assigned part.
+
+### Fixed
+
+- Rejected a key of the wrong circuit, degree or shape before it reaches the dependency's readers, on both verifying keys and on the recursive proving key. One shared key format left each circuit's key decodable in the other's position, where a chosen architecture, degree or fixed commitment count reaches a panic.
+
+### Added
+
+- Documented the constants that asset regeneration must update, with the assertion orientation of each.
+- Decoded the cached key pairs through their typed decoders in the prover setup test, the recursive proving key having had no coverage on a valid key.
+
 ## 0.12.19 (09-15-2026)
 
 ### Added
diff --git a/mithril-stm/Cargo.toml b/mithril-stm/Cargo.toml
index c026bb7e1ca..0d5c6d70019 100644
--- a/mithril-stm/Cargo.toml
+++ b/mithril-stm/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "mithril-stm"
-version = "0.12.19"
+version = "0.12.20"
 edition = { workspace = true }
 authors = { workspace = true }
 homepage = { workspace = true }