Also provide CommonCircuitData in serialization of gates and generators

2026-01-07 16:23:12 +00:00 · 2023-06-28 08:38:02 -04:00 · 2023-06-28 08:38:02 -04:00 · 544aff27b6
commit 544aff27b6
parent 47781e4733
29 changed files with 88 additions and 70 deletions
--- a/evm/src/fixed_recursive_verifier.rs
+++ b/evm/src/fixed_recursive_verifier.rs
@ -831,6 +831,7 @@ where
            buffer.write_prover_only_circuit_data(
                &wrapper.circuit.prover_only,
                generator_serializer,
+                &wrapper.circuit.common,
            )?;
            buffer.write_verifier_only_circuit_data(&wrapper.circuit.verifier_only)?;
            buffer.write_target_proof_with_public_inputs(&wrapper.proof_with_pis_target)?;
--- a/plonky2/examples/square_root.rs
+++ b/plonky2/examples/square_root.rs
@ -52,7 +52,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
        out_buffer.set_target(self.x, x);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_target(self.x)?;
        dst.write_target(self.x_squared)
    }
--- a/plonky2/src/gadgets/arithmetic.rs
+++ b/plonky2/src/gadgets/arithmetic.rs
@ -399,7 +399,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Equ
        out_buffer.set_target(self.inv, inv);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_target(self.x)?;
        dst.write_target(self.y)?;
        dst.write_target_bool(self.equal)?;
--- a/plonky2/src/gadgets/arithmetic_extension.rs
+++ b/plonky2/src/gadgets/arithmetic_extension.rs
@ -522,7 +522,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
        out_buffer.set_extension_target(self.quotient, quotient)
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_target_ext(self.numerator)?;
        dst.write_target_ext(self.denominator)?;
        dst.write_target_ext(self.quotient)
--- a/plonky2/src/gadgets/range_check.rs
+++ b/plonky2/src/gadgets/range_check.rs
@ -79,7 +79,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Low
        out_buffer.set_target(self.high, F::from_canonical_u64(high));
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_target(self.integer)?;
        dst.write_usize(self.n_log)?;
        dst.write_target(self.low)?;
--- a/plonky2/src/gadgets/split_base.rs
+++ b/plonky2/src/gadgets/split_base.rs
@ -110,7 +110,7 @@ impl<F: RichField + Extendable<D>, const B: usize, const D: usize> SimpleGenerat
        out_buffer.set_target(Target::wire(self.row, BaseSumGate::<B>::WIRE_SUM), sum);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
        dst.write_target_bool_vec(&self.limbs)
    }
--- a/plonky2/src/gadgets/split_join.rs
+++ b/plonky2/src/gadgets/split_join.rs
@ -87,7 +87,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Spl
        );
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_target(self.integer)?;
        dst.write_target_vec(&self.bits)
    }
@ -142,7 +142,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Wir
        );
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_target(self.integer)?;
        dst.write_usize_vec(&self.gates)?;
        dst.write_usize(self.num_limbs)
--- a/plonky2/src/gates/arithmetic_base.rs
+++ b/plonky2/src/gates/arithmetic_base.rs
@ -60,7 +60,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ArithmeticGate
        format!("{self:?}")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.num_ops)
    }

@ -221,7 +221,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
        out_buffer.set_target(output_target, computed_output)
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
        dst.write_field(self.const_0)?;
        dst.write_field(self.const_1)?;
--- a/plonky2/src/gates/arithmetic_extension.rs
+++ b/plonky2/src/gates/arithmetic_extension.rs
@ -56,7 +56,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ArithmeticExte
        format!("{self:?}")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.num_ops)
    }

@ -214,7 +214,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
        out_buffer.set_extension_target(output_target, computed_output)
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
        dst.write_field(self.const_0)?;
        dst.write_field(self.const_1)?;
--- a/plonky2/src/gates/base_sum.rs
+++ b/plonky2/src/gates/base_sum.rs
@ -55,7 +55,7 @@ impl<F: RichField + Extendable<D>, const D: usize, const B: usize> Gate<F, D> fo
        format!("{self:?} + Base: {B}")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.num_limbs)
    }

@ -211,7 +211,7 @@ impl<F: RichField + Extendable<D>, const B: usize, const D: usize> SimpleGenerat
        }
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
        dst.write_usize(self.num_limbs)
    }
--- a/plonky2/src/gates/constant.rs
+++ b/plonky2/src/gates/constant.rs
@ -43,7 +43,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ConstantGate {
        format!("{self:?}")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.num_consts)
    }

--- a/plonky2/src/gates/coset_interpolation.rs
+++ b/plonky2/src/gates/coset_interpolation.rs
@ -169,7 +169,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for CosetInterpola
        format!("{self:?}<D={D}>")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.subgroup_bits)?;
        dst.write_usize(self.degree)?;
        dst.write_usize(self.barycentric_weights.len())?;
@ -497,9 +497,9 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
        out_buffer.set_ext_wires(evaluation_value_wires, computed_eval);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
-        self.gate.serialize(dst)
+        self.gate.serialize(dst, _cd)
    }

    fn deserialize(src: &mut Buffer, _cd: &CommonCircuitData<F, D>) -> IoResult<Self> {
--- a/plonky2/src/gates/exponentiation.rs
+++ b/plonky2/src/gates/exponentiation.rs
@ -76,7 +76,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for Exponentiation
        format!("{self:?}<D={D}>")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.num_power_bits)
    }

@ -295,9 +295,9 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
        out_buffer.set_wire(output_wire, intermediate_values[num_power_bits - 1]);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
-        self.gate.serialize(dst)
+        self.gate.serialize(dst, _cd)
    }

    fn deserialize(src: &mut Buffer, _cd: &CommonCircuitData<F, D>) -> IoResult<Self> {
--- a/plonky2/src/gates/gate.rs
+++ b/plonky2/src/gates/gate.rs
@ -29,7 +29,7 @@ use crate::util::serialization::{Buffer, IoResult};
 pub trait Gate<F: RichField + Extendable<D>, const D: usize>: 'static + Send + Sync {
    fn id(&self) -> String;

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()>;
+    fn serialize(&self, dst: &mut Vec<u8>, cd: &CommonCircuitData<F, D>) -> IoResult<()>;

    fn deserialize(src: &mut Buffer, cd: &CommonCircuitData<F, D>) -> IoResult<Self>
    where
--- a/plonky2/src/gates/lookup.rs
+++ b/plonky2/src/gates/lookup.rs
@ -60,7 +60,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for LookupGate {
        format!("{self:?}")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.num_slots)?;
        dst.write_lut(&self.lut)
    }
@ -184,7 +184,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Loo
        out_buffer.set_target(out_wire, output_val);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
        dst.write_lut(&self.lut)?;
        dst.write_usize(self.slot_nb)
--- a/plonky2/src/gates/lookup_table.rs
+++ b/plonky2/src/gates/lookup_table.rs
@ -72,7 +72,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for LookupTableGat
        format!("{self:?}")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.num_slots)?;
        dst.write_lut(&self.lut)?;
        dst.write_usize(self.last_lut_row)
@ -202,7 +202,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Loo
        }
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
        dst.write_lut(&self.lut)?;
        dst.write_usize(self.slot_nb)?;
--- a/plonky2/src/gates/multiplication_extension.rs
+++ b/plonky2/src/gates/multiplication_extension.rs
@ -53,7 +53,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for MulExtensionGa
        format!("{self:?}")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.num_ops)
    }

@ -191,7 +191,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
        out_buffer.set_extension_target(output_target, computed_output)
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
        dst.write_field(self.const_0)?;
        dst.write_usize(self.i)
--- a/plonky2/src/gates/noop.rs
+++ b/plonky2/src/gates/noop.rs
@ -19,7 +19,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for NoopGate {
        "NoopGate".into()
    }

-    fn serialize(&self, _dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, _dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        Ok(())
    }

--- a/plonky2/src/gates/poseidon.rs
+++ b/plonky2/src/gates/poseidon.rs
@ -100,7 +100,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for PoseidonGate<F
        format!("{self:?}<WIDTH={SPONGE_WIDTH}>")
    }

-    fn serialize(&self, _dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, _dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        Ok(())
    }

@ -513,7 +513,7 @@ impl<F: RichField + Extendable<D> + Poseidon, const D: usize> SimpleGenerator<F,
        }
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)
    }

--- a/plonky2/src/gates/poseidon_mds.rs
+++ b/plonky2/src/gates/poseidon_mds.rs
@ -119,7 +119,7 @@ impl<F: RichField + Extendable<D> + Poseidon, const D: usize> Gate<F, D> for Pos
        format!("{self:?}<WIDTH={SPONGE_WIDTH}>")
    }

-    fn serialize(&self, _dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, _dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        Ok(())
    }

@ -251,7 +251,7 @@ impl<F: RichField + Extendable<D> + Poseidon, const D: usize> SimpleGenerator<F,
        }
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)
    }

--- a/plonky2/src/gates/public_input.rs
+++ b/plonky2/src/gates/public_input.rs
@ -32,7 +32,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for PublicInputGat
        "PublicInputGate".into()
    }

-    fn serialize(&self, _dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, _dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        Ok(())
    }

--- a/plonky2/src/gates/random_access.rs
+++ b/plonky2/src/gates/random_access.rs
@ -122,7 +122,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for RandomAccessGa
        format!("{self:?}<D={D}>")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.bits)?;
        dst.write_usize(self.num_copies)?;
        dst.write_usize(self.num_extra_constants)?;
@ -394,10 +394,10 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D>
        }
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
        dst.write_usize(self.copy)?;
-        self.gate.serialize(dst)
+        self.gate.serialize(dst, _cd)
    }

    fn deserialize(src: &mut Buffer, _cd: &CommonCircuitData<F, D>) -> IoResult<Self> {
--- a/plonky2/src/gates/reducing.rs
+++ b/plonky2/src/gates/reducing.rs
@ -61,7 +61,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ReducingGate<D
        format!("{self:?}")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.num_coeffs)?;
        Ok(())
    }
@ -226,9 +226,9 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Red
        out_buffer.set_extension_target(output, acc);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
-        <ReducingGate<D> as Gate<F, D>>::serialize(&self.gate, dst)
+        <ReducingGate<D> as Gate<F, D>>::serialize(&self.gate, dst, _cd)
    }

    fn deserialize(src: &mut Buffer, _cd: &CommonCircuitData<F, D>) -> IoResult<Self> {
--- a/plonky2/src/gates/reducing_extension.rs
+++ b/plonky2/src/gates/reducing_extension.rs
@ -64,7 +64,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ReducingExtens
        format!("{self:?}")
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.num_coeffs)?;
        Ok(())
    }
@ -220,9 +220,9 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Red
        }
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
-        <ReducingExtensionGate<D> as Gate<F, D>>::serialize(&self.gate, dst)
+        <ReducingExtensionGate<D> as Gate<F, D>>::serialize(&self.gate, dst, _cd)
    }

    fn deserialize(src: &mut Buffer, _cd: &CommonCircuitData<F, D>) -> IoResult<Self> {
--- a/plonky2/src/iop/generator.rs
+++ b/plonky2/src/iop/generator.rs
@ -112,7 +112,7 @@ pub trait WitnessGenerator<F: RichField + Extendable<D>, const D: usize>:
    /// run next time a target in its watch list is populated.
    fn run(&self, witness: &PartitionWitness<F>, out_buffer: &mut GeneratedValues<F>) -> bool;

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()>;
+    fn serialize(&self, dst: &mut Vec<u8>, cd: &CommonCircuitData<F, D>) -> IoResult<()>;

    fn deserialize(src: &mut Buffer, cd: &CommonCircuitData<F, D>) -> IoResult<Self>
    where
@ -213,7 +213,7 @@ pub trait SimpleGenerator<F: RichField + Extendable<D>, const D: usize>:
        }
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()>;
+    fn serialize(&self, dst: &mut Vec<u8>, cd: &CommonCircuitData<F, D>) -> IoResult<()>;

    fn deserialize(src: &mut Buffer, cd: &CommonCircuitData<F, D>) -> IoResult<Self>
    where
@ -250,8 +250,8 @@ impl<F: RichField + Extendable<D>, SG: SimpleGenerator<F, D>, const D: usize> Wi
        }
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
-        self.inner.serialize(dst)
+    fn serialize(&self, dst: &mut Vec<u8>, cd: &CommonCircuitData<F, D>) -> IoResult<()> {
+        self.inner.serialize(dst, cd)
    }

    fn deserialize(src: &mut Buffer, cd: &CommonCircuitData<F, D>) -> IoResult<Self> {
@ -283,7 +283,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Cop
        out_buffer.set_target(self.dst, value);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_target(self.src)?;
        dst.write_target(self.dst)
    }
@ -315,7 +315,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Ran
        out_buffer.set_target(self.target, random_value);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_target(self.target)
    }

@ -353,7 +353,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Non
        out_buffer.set_target(self.dummy, dummy_value);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_target(self.to_test)?;
        dst.write_target(self.dummy)
    }
@ -393,7 +393,7 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F, D> for Con
        out_buffer.set_target(Target::wire(self.row, self.wire_index), self.constant);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_usize(self.row)?;
        dst.write_usize(self.constant_index)?;
        dst.write_usize(self.wire_index)?;
--- a/plonky2/src/recursion/dummy_circuit.rs
+++ b/plonky2/src/recursion/dummy_circuit.rs
@ -234,7 +234,7 @@ where
        out_buffer.set_verifier_data_target(&self.verifier_data_target, &self.verifier_data);
    }

-    fn serialize(&self, dst: &mut Vec<u8>) -> IoResult<()> {
+    fn serialize(&self, dst: &mut Vec<u8>, _cd: &CommonCircuitData<F, D>) -> IoResult<()> {
        dst.write_target_proof_with_public_inputs(&self.proof_with_pis_target)?;
        dst.write_proof_with_public_inputs(&self.proof_with_pis)?;
        dst.write_target_verifier_circuit(&self.verifier_data_target)?;
--- a/plonky2/src/util/serialization/gate_serialization.rs
+++ b/plonky2/src/util/serialization/gate_serialization.rs
@ -6,12 +6,13 @@ use crate::plonk::circuit_data::CommonCircuitData;
 use crate::util::serialization::{Buffer, IoResult};

 pub trait GateSerializer<F: RichField + Extendable<D>, const D: usize> {
-    fn read_gate(
+    fn read_gate(&self, buf: &mut Buffer, cd: &CommonCircuitData<F, D>) -> IoResult<GateRef<F, D>>;
+    fn write_gate(
        &self,
-        buf: &mut Buffer,
-        common: &CommonCircuitData<F, D>,
-    ) -> IoResult<GateRef<F, D>>;
-    fn write_gate(&self, buf: &mut Vec<u8>, gate: &GateRef<F, D>) -> IoResult<()>;
+        buf: &mut Vec<u8>,
+        gate: &GateRef<F, D>,
+        cd: &CommonCircuitData<F, D>,
+    ) -> IoResult<()>;
 }

 #[macro_export]
@ -61,11 +62,16 @@ macro_rules! impl_gate_serializer {
            read_gate_impl!(buf, tag, common, $($gate_types),+)
        }

-        fn write_gate(&self, buf: &mut Vec<u8>, gate: &$crate::gates::gate::GateRef<F, D>) -> $crate::util::serialization::IoResult<()> {
+        fn write_gate(
+            &self,
+            buf: &mut Vec<u8>,
+            gate: &$crate::gates::gate::GateRef<F, D>,
+            common: &$crate::plonk::circuit_data::CommonCircuitData<F, D>,
+        ) -> $crate::util::serialization::IoResult<()> {
            let tag = get_gate_tag_impl!(gate, $($gate_types),+)?;

            $crate::util::serialization::Write::write_u32(buf, tag)?;
-            gate.0.serialize(buf)?;
+            gate.0.serialize(buf, common)?;
            Ok(())
        }
    };
--- a/plonky2/src/util/serialization/generator_serialization.rs
+++ b/plonky2/src/util/serialization/generator_serialization.rs
@ -18,6 +18,7 @@ pub trait WitnessGeneratorSerializer<F: RichField + Extendable<D>, const D: usiz
        &self,
        buf: &mut Vec<u8>,
        generator: &WitnessGeneratorRef<F, D>,
+        cd: &CommonCircuitData<F, D>,
    ) -> IoResult<()>;
 }

@ -60,10 +61,6 @@ macro_rules! get_generator_tag_impl {
 /// To serialize a list of generators used for a circuit,
 /// this macro should be called with a struct on which to implement
 /// this as first argument, followed by all the targeted generators.
-///
-/// ***NOTE:*** If you need to include `DummyProofGenerator`, you **MUST**
-/// place it at the *beginning* of the generators list, right after
-/// the serializer struct.
 macro_rules! impl_generator_serializer {
    ($target:ty, $($generator_types:ty),+) => {
        fn read_generator(
@ -79,11 +76,12 @@ macro_rules! impl_generator_serializer {
            &self,
            buf: &mut Vec<u8>,
            generator: &$crate::iop::generator::WitnessGeneratorRef<F, D>,
+            common: &$crate::plonk::circuit_data::CommonCircuitData<F, D>,
        ) -> $crate::util::serialization::IoResult<()> {
            let tag = get_generator_tag_impl!(generator, $($generator_types),+)?;

            $crate::util::serialization::Write::write_u32(buf, tag)?;
-            generator.0.serialize(buf)?;
+            generator.0.serialize(buf, common)?;
            Ok(())
        }
    };
@ -132,13 +130,13 @@ pub mod default {
    {
        impl_generator_serializer! {
            DefaultGeneratorSerializer,
-            DummyProofGenerator<F, C, D>,
            ArithmeticBaseGenerator<F, D>,
            ArithmeticExtensionGenerator<F, D>,
            BaseSplitGenerator<2>,
            BaseSumGenerator<2>,
            ConstantGenerator<F>,
            CopyGenerator,
+            DummyProofGenerator<F, C, D>,
            EqualityGenerator,
            ExponentiationGenerator<F, D>,
            InterpolationGenerator<F, D>,
--- a/plonky2/src/util/serialization/mod.rs
+++ b/plonky2/src/util/serialization/mod.rs
@ -1697,12 +1697,14 @@ pub trait Write {
        &mut self,
        gate: &GateRef<F, D>,
        gate_serializer: &dyn GateSerializer<F, D>,
+        common_data: &CommonCircuitData<F, D>,
    ) -> IoResult<()>;

    fn write_generator<F: RichField + Extendable<D>, const D: usize>(
        &mut self,
        generator: &WitnessGeneratorRef<F, D>,
        generator_serializer: &dyn WitnessGeneratorSerializer<F, D>,
+        common_data: &CommonCircuitData<F, D>,
    ) -> IoResult<()>;

    fn write_selectors_info(&mut self, selectors_info: &SelectorsInfo) -> IoResult<()> {
@ -1785,7 +1787,7 @@ pub trait Write {

        self.write_usize(gates.len())?;
        for gate in gates.iter() {
-            self.write_gate::<F, D>(gate, gate_serializer)?;
+            self.write_gate::<F, D>(gate, gate_serializer, common_data)?;
        }

        Ok(())
@ -1802,7 +1804,11 @@ pub trait Write {
        generator_serializer: &dyn WitnessGeneratorSerializer<F, D>,
    ) -> IoResult<()> {
        self.write_common_circuit_data(&circuit_data.common, gate_serializer)?;
-        self.write_prover_only_circuit_data(&circuit_data.prover_only, generator_serializer)?;
+        self.write_prover_only_circuit_data(
+            &circuit_data.prover_only,
+            generator_serializer,
+            &circuit_data.common,
+        )?;
        self.write_verifier_only_circuit_data(&circuit_data.verifier_only)
    }

@ -1814,6 +1820,7 @@ pub trait Write {
        &mut self,
        prover_only_circuit_data: &ProverOnlyCircuitData<F, C, D>,
        generator_serializer: &dyn WitnessGeneratorSerializer<F, D>,
+        common_data: &CommonCircuitData<F, D>,
    ) -> IoResult<()> {
        let ProverOnlyCircuitData {
            generators,
@ -1831,7 +1838,7 @@ pub trait Write {

        self.write_usize(generators.len())?;
        for generator in generators.iter() {
-            self.write_generator::<F, D>(generator, generator_serializer)?;
+            self.write_generator::<F, D>(generator, generator_serializer, common_data)?;
        }

        self.write_usize(generator_indices_by_watches.len())?;
@ -1891,7 +1898,11 @@ pub trait Write {
        generator_serializer: &dyn WitnessGeneratorSerializer<F, D>,
    ) -> IoResult<()> {
        self.write_common_circuit_data(&prover_circuit_data.common, gate_serializer)?;
-        self.write_prover_only_circuit_data(&prover_circuit_data.prover_only, generator_serializer)
+        self.write_prover_only_circuit_data(
+            &prover_circuit_data.prover_only,
+            generator_serializer,
+            &prover_circuit_data.common,
+        )
    }

    fn write_verifier_only_circuit_data<
@ -2118,16 +2129,18 @@ impl Write for Vec<u8> {
        &mut self,
        gate: &GateRef<F, D>,
        gate_serializer: &dyn GateSerializer<F, D>,
+        common_data: &CommonCircuitData<F, D>,
    ) -> IoResult<()> {
-        gate_serializer.write_gate(self, gate)
+        gate_serializer.write_gate(self, gate, common_data)
    }

    fn write_generator<F: RichField + Extendable<D>, const D: usize>(
        &mut self,
        generator: &WitnessGeneratorRef<F, D>,
        generator_serializer: &dyn WitnessGeneratorSerializer<F, D>,
+        common_data: &CommonCircuitData<F, D>,
    ) -> IoResult<()> {
-        generator_serializer.write_generator(self, generator)
+        generator_serializer.write_generator(self, generator, common_data)
    }
 }