Make BeaconChain::kzg field mandatory (#6267)

* make kzg field required

* update todo

* always load trusted setup WIP

* fmt

* use new rust_eth_kzg version

* merge conlficts

* add kzg fn with trusted setup disabled

* as_slice

* add kzg with no precomp

* ignore udep for kzg

* refactor kzg init

* fix peerdas kzg schedule

* fix

* udeps

* uuuudeps

* merge conflict resolved

* merge conflict

* merge conflicts

* resolve TODO

* update

* move kzg to a test util fn

* remove trusted setup default impl

* lint fmt

* fix failing test

* lint

* fix test

* Merge branch 'unstable' into beacon-chain-kzg-field-required

crypto/kzg/Cargo.toml

@@ -18,11 +18,11 @@ hex = { workspace = true }
 ethereum_hashing = { workspace = true }
 c-kzg = { workspace = true }
 rust_eth_kzg = { workspace = true }
+serde_json = { workspace = true }
 
 [dev-dependencies]
 criterion = { workspace = true }
 serde_json = { workspace = true }
-eth2_network_config = { workspace = true }
 
 [[bench]]
 name = "benchmark"

crypto/kzg/benches/benchmark.rs

@@ -1,11 +1,10 @@
 use c_kzg::KzgSettings;
 use criterion::{criterion_group, criterion_main, Criterion};
-use eth2_network_config::TRUSTED_SETUP_BYTES;
-use kzg::TrustedSetup;
+use kzg::{trusted_setup::get_trusted_setup, TrustedSetup};
 use rust_eth_kzg::{DASContext, TrustedSetup as PeerDASTrustedSetup};
 
 pub fn bench_init_context(c: &mut Criterion) {
-    let trusted_setup: TrustedSetup = serde_json::from_reader(TRUSTED_SETUP_BYTES)
+    let trusted_setup: TrustedSetup = serde_json::from_reader(get_trusted_setup().as_slice())
         .map_err(|e| format!("Unable to read trusted setup file: {}", e))
         .expect("should have trusted setup");
 
@@ -22,9 +21,10 @@ pub fn bench_init_context(c: &mut Criterion) {
     });
     c.bench_function(&format!("Initialize context c-kzg (4844)"), |b| {
         b.iter(|| {
-            let trusted_setup: TrustedSetup = serde_json::from_reader(TRUSTED_SETUP_BYTES)
-                .map_err(|e| format!("Unable to read trusted setup file: {}", e))
-                .expect("should have trusted setup");
+            let trusted_setup: TrustedSetup =
+                serde_json::from_reader(get_trusted_setup().as_slice())
+                    .map_err(|e| format!("Unable to read trusted setup file: {}", e))
+                    .expect("should have trusted setup");
             KzgSettings::load_trusted_setup(&trusted_setup.g1_points(), &trusted_setup.g2_points())
                 .unwrap()
         })

crypto/kzg/src/lib.rs

@@ -1,6 +1,6 @@
 mod kzg_commitment;
 mod kzg_proof;
-mod trusted_setup;
+pub mod trusted_setup;
 
 use rust_eth_kzg::{CellIndex, DASContext};
 use std::fmt::Debug;
@@ -51,18 +51,41 @@ impl From<c_kzg::Error> for Error {
 #[derive(Debug)]
 pub struct Kzg {
     trusted_setup: KzgSettings,
-    context: Option<DASContext>,
+    context: DASContext,
 }
 
 impl Kzg {
-    /// Load the kzg trusted setup parameters from a vec of G1 and G2 points.
-    pub fn new_from_trusted_setup(trusted_setup: TrustedSetup) -> Result<Self, Error> {
+    pub fn new_from_trusted_setup_no_precomp(trusted_setup: TrustedSetup) -> Result<Self, Error> {
+        let peerdas_trusted_setup = PeerDASTrustedSetup::from(&trusted_setup);
+
+        let context = DASContext::new(&peerdas_trusted_setup, rust_eth_kzg::UsePrecomp::No);
+
         Ok(Self {
             trusted_setup: KzgSettings::load_trusted_setup(
                 &trusted_setup.g1_points(),
                 &trusted_setup.g2_points(),
             )?,
-            context: None,
+            context,
+        })
+    }
+
+    /// Load the kzg trusted setup parameters from a vec of G1 and G2 points.
+    pub fn new_from_trusted_setup(trusted_setup: TrustedSetup) -> Result<Self, Error> {
+        let peerdas_trusted_setup = PeerDASTrustedSetup::from(&trusted_setup);
+
+        let context = DASContext::new(
+            &peerdas_trusted_setup,
+            rust_eth_kzg::UsePrecomp::Yes {
+                width: rust_eth_kzg::constants::RECOMMENDED_PRECOMP_WIDTH,
+            },
+        );
+
+        Ok(Self {
+            trusted_setup: KzgSettings::load_trusted_setup(
+                &trusted_setup.g1_points(),
+                &trusted_setup.g2_points(),
+            )?,
+            context,
         })
     }
 
@@ -88,12 +111,12 @@ impl Kzg {
                 &trusted_setup.g1_points(),
                 &trusted_setup.g2_points(),
             )?,
-            context: Some(context),
+            context,
         })
     }
 
-    fn context(&self) -> Result<&DASContext, Error> {
-        self.context.as_ref().ok_or(Error::DASContextUninitialized)
+    fn context(&self) -> &DASContext {
+        &self.context
     }
 
     /// Compute the kzg proof given a blob and its kzg commitment.
@@ -200,7 +223,7 @@ impl Kzg {
         blob: KzgBlobRef<'_>,
     ) -> Result<CellsAndKzgProofs, Error> {
         let (cells, proofs) = self
-            .context()?
+            .context()
             .compute_cells_and_kzg_proofs(blob)
             .map_err(Error::PeerDASKZG)?;
 
@@ -226,7 +249,7 @@ impl Kzg {
             .iter()
             .map(|commitment| commitment.as_ref())
             .collect();
-        let verification_result = self.context()?.verify_cell_kzg_proof_batch(
+        let verification_result = self.context().verify_cell_kzg_proof_batch(
             commitments.to_vec(),
             columns,
             cells.to_vec(),
@@ -247,7 +270,7 @@ impl Kzg {
         cells: &[CellRef<'_>],
     ) -> Result<CellsAndKzgProofs, Error> {
         let (cells, proofs) = self
-            .context()?
+            .context()
             .recover_cells_and_kzg_proofs(cell_ids.to_vec(), cells.to_vec())
             .map_err(Error::PeerDASKZG)?;
 

crypto/kzg/src/trusted_setup.rs

@@ -5,6 +5,12 @@ use serde::{
     Deserialize, Serialize,
 };
 
+pub const TRUSTED_SETUP_BYTES: &[u8] = include_bytes!("../trusted_setup.json");
+
+pub fn get_trusted_setup() -> Vec<u8> {
+    TRUSTED_SETUP_BYTES.into()
+}
+
 /// Wrapper over a BLS G1 point's byte representation.
 #[derive(Debug, Clone, PartialEq)]
 struct G1Point([u8; BYTES_PER_G1_POINT]);