feat(akita-field): add serde to akita-field

crates/akita-field/Cargo.toml

@@ -22,6 +22,7 @@ jolt-field = { git = "https://github.com/a16z/jolt", rev = "2509bdcea9bb3e8978bb
 num-traits = "0.2"
 rand_core = { version = "0.6", features = ["getrandom"] }
 rayon = { version = "1.10", optional = true }
+serde = "1"
 thiserror = "2.0"
 
 [dev-dependencies]

crates/akita-field/src/ext/mod.rs

@@ -10,6 +10,7 @@ mod fp_ext4;
 mod fp_ext8;
 pub(crate) mod lift;
 mod native_algebra;
+mod serde_support;
 #[cfg(test)]
 mod tests;
 

crates/akita-field/src/ext/serde_support.rs

@@ -0,0 +1,38 @@
+//! `serde` for the extension fields, as base-coefficient arrays.
+//!
+//! An element encodes as its `[F; K]` coefficients in the same basis order as
+//! [`AkitaSerialize`](akita_serialization::AkitaSerialize), so canonicality is
+//! enforced by the base field's own decode. As with the prime fields, this is a
+//! host and tooling surface: verifier-reachable decoding stays on
+//! [`AkitaDeserialize`](akita_serialization::AkitaDeserialize), which is the
+//! only path that bounds container lengths.
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use super::{FpExt2, FpExt2Config, FpExt4, FpExt8};
+use crate::FieldCore;
+
+/// Implements serde for one extension arity. `$cfg` is the extension-config
+/// parameter, which only `FpExt2` carries.
+macro_rules! impl_ext_serde {
+    ($ty:ident $(, $cfg:ident: $bound:path)?; $k:literal; |$coeffs:ident| $new:expr) => {
+        impl<F: FieldCore + Serialize $(, $cfg: $bound)?> Serialize for $ty<F $(, $cfg)?> {
+            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+                self.coeffs.serialize(serializer)
+            }
+        }
+
+        impl<'de, F: FieldCore + Deserialize<'de> $(, $cfg: $bound)?> Deserialize<'de>
+            for $ty<F $(, $cfg)?>
+        {
+            fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+                let $coeffs = <[F; $k]>::deserialize(deserializer)?;
+                Ok($new)
+            }
+        }
+    };
+}
+
+impl_ext_serde!(FpExt2, C: FpExt2Config<F>; 2; |coeffs| Self::new(coeffs[0], coeffs[1]));
+impl_ext_serde!(FpExt4; 4; |coeffs| Self::new(coeffs));
+impl_ext_serde!(FpExt8; 8; |coeffs| Self::new(coeffs));

crates/akita-field/src/prime/mod.rs

@@ -12,6 +12,7 @@ pub(crate) mod fp64;
 mod native_algebra;
 mod native_capability;
 pub(crate) mod pseudo_mersenne;
+mod serde_support;
 pub(crate) mod util;
 
 pub use fp128::{

crates/akita-field/src/prime/serde_support.rs

@@ -0,0 +1,42 @@
+//! `serde` for the prime fields, over the canonical residue.
+//!
+//! An element encodes as its canonical representative in the field's storage
+//! width; decode rejects non-canonical values (`val >= P`) rather than reducing.
+//!
+//! This is a host and tooling surface. Akita's protocol wire format is
+//! [`AkitaSerialize`](akita_serialization::AkitaSerialize) /
+//! [`AkitaDeserialize`](akita_serialization::AkitaDeserialize), and
+//! verifier-reachable decoding stays there: a serde format bounds sequence
+//! lengths only if its consumer configured a limit, so these impls cannot make
+//! the container guarantee that `AkitaDeserialize` does.
+
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+use super::{Fp128, Fp32, Fp64};
+use crate::CanonicalField;
+
+macro_rules! impl_prime_serde {
+    ($ty:ident<$p:ident: $p_ty:ty>) => {
+        impl<const $p: $p_ty> Serialize for $ty<$p> {
+            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+                (self.to_canonical_u128() as $p_ty).serialize(serializer)
+            }
+        }
+
+        impl<'de, const $p: $p_ty> Deserialize<'de> for $ty<$p> {
+            fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+                let raw = <$p_ty as Deserialize>::deserialize(deserializer)?;
+                Self::from_canonical_u128_checked(u128::from(raw)).ok_or_else(|| {
+                    de::Error::custom(format_args!(
+                        concat!(stringify!($ty), " value {} is not a canonical residue"),
+                        raw
+                    ))
+                })
+            }
+        }
+    };
+}
+
+impl_prime_serde!(Fp32<P: u32>);
+impl_prime_serde!(Fp64<P: u64>);
+impl_prime_serde!(Fp128<P: u128>);