Upgrade rust-eth-kzg to 0.8.0.

Author: jimmygchen

Cargo.lock

@@ -221,7 +221,7 @@ reqwest = { version = "0.11", default-features = false, features = [
 ring = "0.17"
 rpds = "0.11"
 rusqlite = { version = "0.28", features = ["bundled"] }
-rust_eth_kzg = "0.5.4"
+rust_eth_kzg = "0.8.0"
 safe_arith = { path = "consensus/safe_arith" }
 sensitive_url = { path = "common/sensitive_url" }
 serde = { version = "1", features = ["derive"] }

Cargo.toml

@@ -423,7 +423,7 @@ mod test {
     use bls::Signature;
     use eth2::types::BlobsBundle;
     use execution_layer::test_utils::generate_blobs;
-    use kzg::{trusted_setup::get_trusted_setup, Kzg, KzgCommitment, TrustedSetup};
+    use kzg::{trusted_setup::get_trusted_setup, Kzg, KzgCommitment};
     use types::{
         beacon_block_body::KzgCommitments, BeaconBlock, BeaconBlockFulu, BlobsList, ChainSpec,
         EmptyBlock, EthSpec, ForkName, FullPayload, KzgProofs, MainnetEthSpec, SignedBeaconBlock,
@@ -568,10 +568,7 @@ mod test {
     }
 
     fn get_kzg() -> Kzg {
-        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");
-        Kzg::new_from_trusted_setup_das_enabled(trusted_setup).expect("should create kzg")
+        Kzg::new_from_trusted_setup(&get_trusted_setup()).expect("should create kzg")
     }
 
     fn create_test_fulu_block_and_blobs<E: EthSpec>(

beacon_node/beacon_chain/src/kzg_utils.rs

@@ -33,7 +33,7 @@ use futures::channel::mpsc::Receiver;
 pub use genesis::{InteropGenesisBuilder, DEFAULT_ETH1_BLOCK_HASH};
 use int_to_bytes::int_to_bytes32;
 use kzg::trusted_setup::get_trusted_setup;
-use kzg::{Kzg, TrustedSetup};
+use kzg::Kzg;
 use logging::create_test_tracing_subscriber;
 use merkle_proof::MerkleTree;
 use operation_pool::ReceivedPreCapella;
@@ -81,33 +81,18 @@ pub const TEST_DATA_COLUMN_SIDECARS_SSZ: &[u8] =
 pub const DEFAULT_TARGET_AGGREGATORS: u64 = u64::MAX;
 
 static KZG: LazyLock<Arc<Kzg>> = LazyLock::new(|| {
-    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");
-    let kzg = Kzg::new_from_trusted_setup(trusted_setup).expect("should create kzg");
-    Arc::new(kzg)
-});
-
-static KZG_PEERDAS: LazyLock<Arc<Kzg>> = LazyLock::new(|| {
-    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");
-    let kzg = Kzg::new_from_trusted_setup_das_enabled(trusted_setup).expect("should create kzg");
+    let kzg = Kzg::new_from_trusted_setup(&get_trusted_setup()).expect("should create kzg");
     Arc::new(kzg)
 });
 
 static KZG_NO_PRECOMP: LazyLock<Arc<Kzg>> = LazyLock::new(|| {
-    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");
-    let kzg = Kzg::new_from_trusted_setup_no_precomp(trusted_setup).expect("should create kzg");
+    let kzg =
+        Kzg::new_from_trusted_setup_no_precomp(&get_trusted_setup()).expect("should create kzg");
     Arc::new(kzg)
 });
 
 pub fn get_kzg(spec: &ChainSpec) -> Arc<Kzg> {
     if spec.fulu_fork_epoch.is_some() {
-        KZG_PEERDAS.clone()
-    } else if spec.deneb_fork_epoch.is_some() {
         KZG.clone()
     } else {
         KZG_NO_PRECOMP.clone()

beacon_node/beacon_chain/src/test_utils.rs

@@ -185,13 +185,10 @@ where
         };
 
         let kzg_err_msg = |e| format!("Failed to load trusted setup: {:?}", e);
-        let trusted_setup = config.trusted_setup.clone();
         let kzg = if spec.is_peer_das_scheduled() {
-            Kzg::new_from_trusted_setup_das_enabled(trusted_setup).map_err(kzg_err_msg)?
-        } else if spec.deneb_fork_epoch.is_some() {
-            Kzg::new_from_trusted_setup(trusted_setup).map_err(kzg_err_msg)?
+            Kzg::new_from_trusted_setup(&config.trusted_setup).map_err(kzg_err_msg)?
         } else {
-            Kzg::new_from_trusted_setup_no_precomp(trusted_setup).map_err(kzg_err_msg)?
+            Kzg::new_from_trusted_setup_no_precomp(&config.trusted_setup).map_err(kzg_err_msg)?
         };
 
         let builder = BeaconChainBuilder::new(eth_spec_instance, Arc::new(kzg))

beacon_node/client/src/builder.rs

@@ -1,6 +1,5 @@
 use beacon_chain::graffiti_calculator::GraffitiOrigin;
 use beacon_chain::validator_monitor::ValidatorMonitorConfig;
-use beacon_chain::TrustedSetup;
 use beacon_processor::BeaconProcessorConfig;
 use directory::DEFAULT_ROOT_DIR;
 use environment::LoggerConfig;
@@ -70,7 +69,7 @@ pub struct Config {
     pub network: network::NetworkConfig,
     pub chain: beacon_chain::ChainConfig,
     pub execution_layer: Option<execution_layer::Config>,
-    pub trusted_setup: TrustedSetup,
+    pub trusted_setup: Vec<u8>,
     pub http_api: http_api::Config,
     pub http_metrics: http_metrics::Config,
     pub monitoring_api: Option<monitoring_api::Config>,
@@ -84,9 +83,6 @@ pub struct Config {
 
 impl Default for Config {
     fn default() -> Self {
-        let trusted_setup: TrustedSetup = serde_json::from_reader(get_trusted_setup().as_slice())
-            .expect("Unable to read trusted setup file");
-
         Self {
             data_dir: PathBuf::from(DEFAULT_ROOT_DIR),
             db_name: "chain_db".to_string(),
@@ -98,7 +94,7 @@ impl Default for Config {
             network: NetworkConfig::default(),
             chain: <_>::default(),
             execution_layer: None,
-            trusted_setup,
+            trusted_setup: get_trusted_setup(),
             beacon_graffiti: GraffitiOrigin::default(),
             http_api: <_>::default(),
             http_metrics: <_>::default(),

beacon_node/client/src/config.rs

@@ -937,7 +937,7 @@ pub fn generate_pow_block(
 #[cfg(test)]
 mod test {
     use super::*;
-    use kzg::{trusted_setup::get_trusted_setup, Bytes48, CellRef, KzgBlobRef, TrustedSetup};
+    use kzg::{trusted_setup::get_trusted_setup, Bytes48, CellRef, KzgBlobRef};
     use types::{MainnetEthSpec, MinimalEthSpec};
 
     #[test]
@@ -1056,10 +1056,7 @@ mod test {
     }
 
     fn load_kzg() -> Result<Kzg, String> {
-        let trusted_setup: TrustedSetup =
-            serde_json::from_reader(get_trusted_setup().as_slice())
-                .map_err(|e| format!("Unable to read trusted setup file: {e:?}"))?;
-        Kzg::new_from_trusted_setup(trusted_setup)
+        Kzg::new_from_trusted_setup(&get_trusted_setup())
             .map_err(|e| format!("Failed to load trusted setup: {e:?}"))
     }
 }