Bump ssz_types to v0.12.2

Cargo.toml

@@ -238,7 +238,7 @@ slashing_protection = { path = "validator_client/slashing_protection" }
 slot_clock = { path = "common/slot_clock" }
 smallvec = { version = "1.11.2", features = ["arbitrary"] }
 snap = "1"
-ssz_types = "0.11.0"
+ssz_types = "0.12.1"
 state_processing = { path = "consensus/state_processing" }
 store = { path = "beacon_node/store" }
 strum = { version = "0.24", features = ["derive"] }

beacon_node/beacon_chain/benches/benches.rs

@@ -26,8 +26,11 @@ fn create_test_block_and_blobs<E: EthSpec>(
     let blobs = (0..num_of_blobs)
         .map(|_| Blob::<E>::default())
         .collect::<Vec<_>>()
-        .into();
-    let proofs = vec![KzgProof::empty(); num_of_blobs * E::number_of_columns()].into();
+        .try_into()
+        .unwrap();
+    let proofs = vec![KzgProof::empty(); num_of_blobs * E::number_of_columns()]
+        .try_into()
+        .unwrap();
 
     (signed_block, blobs, proofs)
 }

beacon_node/beacon_chain/src/data_column_verification.rs

@@ -839,16 +839,16 @@ mod test {
         let state = harness.get_current_state();
         let ((block, _blobs_opt), _state) = harness
             .make_block_with_modifier(state, slot, |block| {
-                *block.body_mut().blob_kzg_commitments_mut().unwrap() = vec![].into();
+                *block.body_mut().blob_kzg_commitments_mut().unwrap() = vec![].try_into().unwrap();
             })
             .await;
 
         let index = 0;
         let column_sidecar = DataColumnSidecar::<E> {
             index,
-            column: vec![].into(),
-            kzg_commitments: vec![].into(),
-            kzg_proofs: vec![].into(),
+            column: vec![].try_into().unwrap(),
+            kzg_commitments: vec![].try_into().unwrap(),
+            kzg_proofs: vec![].try_into().unwrap(),
             signed_block_header: block.signed_block_header(),
             kzg_commitments_inclusion_proof: block
                 .message()

beacon_node/beacon_chain/src/errors.rs

@@ -300,6 +300,7 @@ pub enum BlockProductionError {
     KzgError(kzg::Error),
     FailedToBuildBlobSidecars(String),
     MissingExecutionRequests,
+    SszTypesError(ssz_types::Error),
 }
 
 easy_from_to!(BlockProcessingError, BlockProductionError);

beacon_node/beacon_chain/src/fetch_blobs/tests.rs

@@ -576,7 +576,7 @@ fn create_test_block_and_blobs(
             .map(|(blob, proofs)| {
                 BlobAndProof::V2(BlobAndProofV2 {
                     blob,
-                    proofs: proofs.to_vec().into(),
+                    proofs: proofs.to_vec().try_into().unwrap(),
                 })
             })
             .collect()

beacon_node/beacon_chain/src/kzg_utils.rs

@@ -251,7 +251,8 @@ pub(crate) fn build_data_column_sidecars<E: EthSpec>(
                 .get(col)
                 .ok_or(format!("Missing blob cell at index {col}"))?;
             let cell: Vec<u8> = cell.to_vec();
-            let cell = Cell::<E>::from(cell);
+            let cell =
+                Cell::<E>::try_from(cell).map_err(|e| format!("BytesPerCell exceeded: {e:?}"))?;
 
             let proof = blob_cell_proofs
                 .get(col)
@@ -269,23 +270,27 @@ pub(crate) fn build_data_column_sidecars<E: EthSpec>(
         }
     }
 
-    let sidecars: Vec<Arc<DataColumnSidecar<E>>> = columns
+    let sidecars: Result<Vec<Arc<DataColumnSidecar<E>>>, String> = columns
         .into_iter()
         .zip(column_kzg_proofs)
         .enumerate()
-        .map(|(index, (col, proofs))| {
-            Arc::new(DataColumnSidecar {
-                index: index as u64,
-                column: DataColumn::<E>::from(col),
-                kzg_commitments: kzg_commitments.clone(),
-                kzg_proofs: VariableList::from(proofs),
-                signed_block_header: signed_block_header.clone(),
-                kzg_commitments_inclusion_proof: kzg_commitments_inclusion_proof.clone(),
-            })
-        })
+        .map(
+            |(index, (col, proofs))| -> Result<Arc<DataColumnSidecar<E>>, String> {
+                Ok(Arc::new(DataColumnSidecar {
+                    index: index as u64,
+                    column: DataColumn::<E>::try_from(col)
+                        .map_err(|e| format!("MaxBlobCommitmentsPerBlock exceeded: {e:?}"))?,
+                    kzg_commitments: kzg_commitments.clone(),
+                    kzg_proofs: VariableList::try_from(proofs)
+                        .map_err(|e| format!("MaxBlobCommitmentsPerBlock exceeded: {e:?}"))?,
+                    signed_block_header: signed_block_header.clone(),
+                    kzg_commitments_inclusion_proof: kzg_commitments_inclusion_proof.clone(),
+                }))
+            },
+        )
         .collect();
 
-    Ok(sidecars)
+    sidecars
 }
 
 /// Reconstruct blobs from a subset of data column sidecars (requires at least 50%).

beacon_node/beacon_chain/src/test_utils.rs

@@ -2323,7 +2323,7 @@ where
             .collect::<Vec<_>>();
 
         // Building a VarList from leaves
-        let deposit_data_list = VariableList::<_, U4294967296>::from(leaves.clone());
+        let deposit_data_list = VariableList::<_, U4294967296>::try_from(leaves.clone()).unwrap();
 
         // Setting the deposit_root to be the tree_hash_root of the VarList
         state.eth1_data_mut().deposit_root = deposit_data_list.tree_hash_root();
@@ -2347,7 +2347,7 @@ where
         let deposits = datas
             .into_par_iter()
             .zip(proofs.into_par_iter())
-            .map(|(data, proof)| (data, proof.into()))
+            .map(|(data, proof)| (data, proof.try_into().unwrap()))
             .map(|(data, proof)| Deposit { proof, data })
             .collect::<Vec<_>>();
 

beacon_node/beacon_chain/tests/block_verification.rs

@@ -699,7 +699,7 @@ async fn invalid_signature_attester_slashing() {
 
         let attester_slashing = if fork_name.electra_enabled() {
             let indexed_attestation = IndexedAttestationElectra {
-                attesting_indices: vec![0].into(),
+                attesting_indices: vec![0].try_into().unwrap(),
                 data: AttestationData {
                     slot: Slot::new(0),
                     index: 0,
@@ -723,7 +723,7 @@ async fn invalid_signature_attester_slashing() {
             AttesterSlashing::Electra(attester_slashing)
         } else {
             let indexed_attestation = IndexedAttestationBase {
-                attesting_indices: vec![0].into(),
+                attesting_indices: vec![0].try_into().unwrap(),
                 data: AttestationData {
                     slot: Slot::new(0),
                     index: 0,
@@ -890,7 +890,9 @@ async fn invalid_signature_deposit() {
         let harness = get_invalid_sigs_harness(&chain_segment).await;
         let mut snapshots = chain_segment.clone();
         let deposit = Deposit {
-            proof: vec![Hash256::zero(); DEPOSIT_TREE_DEPTH + 1].into(),
+            proof: vec![Hash256::zero(); DEPOSIT_TREE_DEPTH + 1]
+                .try_into()
+                .unwrap(),
             data: DepositData {
                 pubkey: Keypair::random().pk.into(),
                 withdrawal_credentials: Hash256::zero(),
@@ -1262,7 +1264,9 @@ async fn block_gossip_verification() {
         as usize;
 
     if let Ok(kzg_commitments) = block.body_mut().blob_kzg_commitments_mut() {
-        *kzg_commitments = vec![KzgCommitment::empty_for_testing(); kzg_commitments_len + 1].into();
+        *kzg_commitments = vec![KzgCommitment::empty_for_testing(); kzg_commitments_len + 1]
+            .try_into()
+            .unwrap();
         assert!(
             matches!(
                 unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(SignedBeaconBlock::from_block(block, signature))).await),

beacon_node/execution_layer/src/engine_api/http.rs

@@ -1814,16 +1814,16 @@ mod test {
                                 fee_recipient: Address::repeat_byte(1),
                                 state_root: Hash256::repeat_byte(1),
                                 receipts_root: Hash256::repeat_byte(0),
-                                logs_bloom: vec![1; 256].into(),
+                                logs_bloom: vec![1; 256].try_into().unwrap(),
                                 prev_randao: Hash256::repeat_byte(1),
                                 block_number: 0,
                                 gas_limit: 1,
                                 gas_used: 2,
                                 timestamp: 42,
-                                extra_data: vec![].into(),
+                                extra_data: vec![].try_into().unwrap(),
                                 base_fee_per_gas: Uint256::from(1),
                                 block_hash: ExecutionBlockHash::repeat_byte(1),
-                                transactions: vec![].into(),
+                                transactions: vec![].try_into().unwrap(),
                             },
                         ))
                         .await;
@@ -1861,16 +1861,16 @@ mod test {
                             fee_recipient: Address::repeat_byte(1),
                             state_root: Hash256::repeat_byte(1),
                             receipts_root: Hash256::repeat_byte(0),
-                            logs_bloom: vec![1; 256].into(),
+                            logs_bloom: vec![1; 256].try_into().unwrap(),
                             prev_randao: Hash256::repeat_byte(1),
                             block_number: 0,
                             gas_limit: 1,
                             gas_used: 2,
                             timestamp: 42,
-                            extra_data: vec![].into(),
+                            extra_data: vec![].try_into().unwrap(),
                             base_fee_per_gas: Uint256::from(1),
                             block_hash: ExecutionBlockHash::repeat_byte(1),
-                            transactions: vec![].into(),
+                            transactions: vec![].try_into().unwrap(),
                         },
                     ))
                     .await
@@ -2071,16 +2071,16 @@ mod test {
                             fee_recipient: Address::from_str("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b").unwrap(),
                             state_root: Hash256::from_str("0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45").unwrap(),
                             receipts_root: Hash256::from_str("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap(),
-                            logs_bloom: vec![0; 256].into(),
+                            logs_bloom: vec![0; 256].try_into().unwrap(),
                             prev_randao: Hash256::zero(),
                             block_number: 1,
                             gas_limit: u64::from_str_radix("1c95111",16).unwrap(),
                             gas_used: 0,
                             timestamp: 5,
-                            extra_data: vec![].into(),
+                            extra_data: vec![].try_into().unwrap(),
                             base_fee_per_gas: Uint256::from(7),
                             block_hash: ExecutionBlockHash::from_str("0x6359b8381a370e2f54072a5784ddd78b6ed024991558c511d4452eb4f6ac898c").unwrap(),
-                            transactions: vec![].into(),
+                            transactions: vec![].try_into().unwrap(),
                         });
 
                     assert_eq!(payload, expected);
@@ -2096,16 +2096,16 @@ mod test {
                             fee_recipient: Address::from_str("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b").unwrap(),
                             state_root: Hash256::from_str("0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45").unwrap(),
                             receipts_root: Hash256::from_str("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").unwrap(),
-                            logs_bloom: vec![0; 256].into(),
+                            logs_bloom: vec![0; 256].try_into().unwrap(),
                             prev_randao: Hash256::zero(),
                             block_number: 1,
                             gas_limit: u64::from_str_radix("1c9c380",16).unwrap(),
                             gas_used: 0,
                             timestamp: 5,
-                            extra_data: vec![].into(),
+                            extra_data: vec![].try_into().unwrap(),
                             base_fee_per_gas: Uint256::from(7),
                             block_hash: ExecutionBlockHash::from_str("0x3559e851470f6e7bbed1db474980683e8c315bfce99b2a6ef47c057c04de7858").unwrap(),
-                            transactions: vec![].into(),
+                            transactions: vec![].try_into().unwrap(),
                         }))
                         .await;
                 },