Bump the toolchain to nightly-2026-01-22

0xVolosnikov · perekopskiy · commit 591e74047f1e · 2026-02-26T18:32:43.000+01:00
diff --git a/basic_bootloader/src/lib.rs b/basic_bootloader/src/lib.rs
@@ -2,7 +2,6 @@
 #![feature(allocator_api)]
 #![allow(incomplete_features)]
 #![feature(generic_const_exprs)]
-#![feature(array_chunks)]
 #![feature(get_mut_unchecked)]
 #![feature(const_type_id)]
 #![feature(vec_push_within_capacity)]
diff --git a/basic_system/src/lib.rs b/basic_system/src/lib.rs
@@ -2,7 +2,6 @@
 #![allow(incomplete_features)]
 #![feature(generic_const_exprs)]
 #![feature(allocator_api)]
-#![feature(array_chunks)]
 #![feature(get_mut_unchecked)]
 #![feature(const_type_id)]
 #![feature(vec_push_within_capacity)]
diff --git a/basic_system/src/system_functions/bn254_ecmul.rs b/basic_system/src/system_functions/bn254_ecmul.rs
@@ -54,7 +54,7 @@ fn bn254_ecmul_as_system_function_inner<
         *dst = *src;
     }
 
-    let mut it = buffer.array_chunks::<32>();
+    let mut it = buffer.as_chunks::<32>().0.iter();
     let serialized_result = unsafe {
         let x0 = it.next().unwrap_unchecked();
         let y0 = it.next().unwrap_unchecked();
diff --git a/basic_system/src/system_functions/bn254_pairing_check.rs b/basic_system/src/system_functions/bn254_pairing_check.rs
@@ -85,7 +85,7 @@ fn bn254_pairing_check_inner<A: Allocator>(
         for (dst, src) in buffer.iter_mut().zip(&mut src_iter) {
             *dst = *src;
         }
-        let mut it = buffer.array_chunks::<32>();
+        let mut it = buffer.as_chunks::<32>().0.iter();
         unsafe {
             let mut g1_x = *it.next().unwrap_unchecked();
             let mut g1_y = *it.next().unwrap_unchecked();
diff --git a/basic_system/src/system_functions/ecrecover.rs b/basic_system/src/system_functions/ecrecover.rs
@@ -52,7 +52,7 @@ fn ecrecover_as_system_function_inner<
 
     // follow https://github.com/ethereum/go-ethereum/blob/aadcb886753079d419f966a3bc990f708f8d1c3b/core/vm/contracts.go#L188
 
-    let mut it = buffer.array_chunks::<32>();
+    let mut it = buffer.as_chunks::<32>().0.iter();
     let recovered_pubkey_bytes = unsafe {
         let digest = it.next().unwrap_unchecked();
         let v = it.next().unwrap_unchecked();
diff --git a/basic_system/src/system_functions/p256_verify.rs b/basic_system/src/system_functions/p256_verify.rs
@@ -70,7 +70,7 @@ fn p256_verify_as_system_function_inner<
         *dst = *src;
     }
 
-    let mut it = buffer.array_chunks::<32>();
+    let mut it = buffer.as_chunks::<32>().0.iter();
     let is_valid = unsafe {
         let digest = it.next().unwrap_unchecked();
         let r = it.next().unwrap_unchecked();
diff --git a/basic_system/src/system_implementation/system/da_commitment_generator/blob_commitment_generator/commitment_and_proof_advice.rs b/basic_system/src/system_implementation/system/da_commitment_generator/blob_commitment_generator/commitment_and_proof_advice.rs
@@ -21,8 +21,8 @@ impl UsizeSerializable for KZGCommitmentAndProof {
             } else {
                 #[allow(clippy::needless_return)]
                 return ExactSizeChain::new(
-                    self.commitment.array_chunks::<{ core::mem::size_of::<usize>() }>().map(|chunk| usize::from_le_bytes(*chunk)),
-                    self.proof.array_chunks::<{ core::mem::size_of::<usize>() }>().map(|chunk| usize::from_le_bytes(*chunk)),
+                    self.commitment.as_chunks::<{ core::mem::size_of::<usize>() }>().0.iter().map(|chunk| usize::from_le_bytes(*chunk)),
+                    self.proof.as_chunks::<{ core::mem::size_of::<usize>() }>().0.iter().map(|chunk| usize::from_le_bytes(*chunk)),
                 );
             }
         );
diff --git a/basic_system/src/system_implementation/system/da_commitment_generator/blob_commitment_generator/polynomial_evaluation.rs b/basic_system/src/system_implementation/system/da_commitment_generator/blob_commitment_generator/polynomial_evaluation.rs
@@ -16,8 +16,7 @@ pub fn evaluate_blob_polynomial(data: &[u8], x: &crypto::bls12_381::Fr) -> crypt
         [MaybeUninit::uninit(); ELEMENTS_PER_4844_BLOB];
     let mut poly_iter = poly.iter_mut();
 
-    let chunks = data.array_chunks::<BLOB_CHUNK_SIZE>();
-    let remainder = chunks.remainder();
+    let (chunks, remainder) = data.as_chunks::<BLOB_CHUNK_SIZE>();
     for chunk in chunks {
         poly_iter
             .next()
diff --git a/callable_oracles/src/hash_to_prime/common.rs b/callable_oracles/src/hash_to_prime/common.rs
@@ -203,7 +203,7 @@ pub fn create_entropy(source: &[u8]) -> [u8; 64] {
     use crypto::blake2s::Blake2s256;
     assert!(MAX_ENTROPY_BYTES <= 64);
     let mut entropy = [0u8; 64];
-    for (idx, dst) in entropy.array_chunks_mut::<32>().enumerate() {
+    for (idx, dst) in entropy.as_chunks_mut::<32>().0.iter_mut().enumerate() {
         let mut hasher = Blake2s256::new();
         hasher.update(&(idx as u32).to_le_bytes());
         hasher.update(&source);
diff --git a/callable_oracles/src/lib.rs b/callable_oracles/src/lib.rs
@@ -1,8 +1,6 @@
 #![cfg_attr(all(not(feature = "evaluate"), not(test)), no_std)]
 #![allow(incomplete_features)]
 #![feature(generic_const_exprs)]
-#![feature(array_chunks)]
-#![feature(iter_array_chunks)]
 #![allow(clippy::new_without_default)]
 #![allow(clippy::needless_lifetimes)]
 #![allow(clippy::needless_borrow)]
diff --git a/crypto/src/lib.rs b/crypto/src/lib.rs
@@ -1,5 +1,4 @@
 #![cfg_attr(not(test), no_std)]
-#![feature(array_chunks)]
 #![allow(static_mut_refs)]
 #![allow(clippy::uninit_assumed_init)]
 #![allow(clippy::new_without_default)]
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -1,2 +1,2 @@
 [toolchain]
-channel = "nightly-2025-05-23"
+channel = "nightly-2026-01-22"
diff --git a/supporting_crates/solidity_abi/src/impls/byte_ref.rs b/supporting_crates/solidity_abi/src/impls/byte_ref.rs
@@ -58,14 +58,14 @@ impl<'a> SolidityCodableReflectionRef<'a> for BytesRef<'a> {
         if local_head.len() < 32 {
             return Err(());
         }
-        let tail_offset = local_head.array_chunks::<32>().next().unwrap();
+        let tail_offset = local_head.as_chunks::<32>().0.iter().next().unwrap();
         let tail_offset = U256::from_be_bytes(*tail_offset);
         let tail_offset = u256_to_usize_checked(&tail_offset)?;
         let (_, local_tail) = source.split_at_checked(tail_offset).ok_or(())?;
         if local_tail.len() < 32 {
             return Err(());
         }
-        let len = local_tail.array_chunks::<32>().next().unwrap();
+        let len = local_tail.as_chunks::<32>().0.iter().next().unwrap();
         let len = U256::from_be_bytes(*len);
         let len = u256_to_usize_checked(&len)?;
         let (_, bytes_body) = local_tail.split_at_checked(32).ok_or(())?;
@@ -87,14 +87,14 @@ impl<'a> SolidityCodableReflectionRefMut<'a> for BytesRefMut<'a> {
         if local_head.len() < 32 {
             return Err(());
         }
-        let tail_offset = local_head.array_chunks::<32>().next().unwrap();
+        let tail_offset = local_head.as_chunks::<32>().0.iter().next().unwrap();
         let tail_offset = U256::from_be_bytes(*tail_offset);
         let tail_offset = u256_to_usize_checked(&tail_offset)?;
         let (_, local_tail) = source.split_at_mut_checked(tail_offset).ok_or(())?;
         if local_tail.len() < 32 {
             return Err(());
         }
-        let len = local_tail.array_chunks::<32>().next().unwrap();
+        let len = local_tail.as_chunks::<32>().0.iter().next().unwrap();
         let len = U256::from_be_bytes(*len);
         let len = u256_to_usize_checked(&len)?;
         let (_, bytes_body) = local_tail.split_at_mut_checked(32).ok_or(())?;
diff --git a/supporting_crates/solidity_abi/src/impls/codable_array.rs b/supporting_crates/solidity_abi/src/impls/codable_array.rs
@@ -98,14 +98,14 @@ impl<'a, T: SolidityCodable + 'a, const N: usize> SolidityCodableReflectionRef<'
             return Err(());
         }
         let array_source = if T::IS_DYNAMIC {
-            let tail_offset = local_head.array_chunks::<32>().next().unwrap();
+            let tail_offset = local_head.as_chunks::<32>().0.iter().next().unwrap();
             let tail_offset = U256::from_be_bytes(*tail_offset);
             let tail_offset = u256_to_usize_checked(&tail_offset)?;
             let (_, local_tail) = source.split_at_checked(tail_offset).ok_or(())?;
             if local_tail.len() < 32 {
                 return Err(());
             }
-            let len = local_tail.array_chunks::<32>().next().unwrap();
+            let len = local_tail.as_chunks::<32>().0.iter().next().unwrap();
             let len = U256::from_be_bytes(*len);
             let len = u256_to_usize_checked(&len)?;
             let (_, body) = local_tail.split_at_checked(32).ok_or(())?;
@@ -142,14 +142,14 @@ impl<'a, T: SolidityCodable + 'a, const N: usize> SolidityCodableReflectionRefMu
             return Err(());
         }
         let array_source = if T::IS_DYNAMIC {
-            let tail_offset = local_head.array_chunks::<32>().next().unwrap();
+            let tail_offset = local_head.as_chunks::<32>().0.iter().next().unwrap();
             let tail_offset = U256::from_be_bytes(*tail_offset);
             let tail_offset = u256_to_usize_checked(&tail_offset)?;
             let (_, local_tail) = source.split_at_mut_checked(tail_offset).ok_or(())?;
             if local_tail.len() < 32 {
                 return Err(());
             }
-            let len = local_tail.array_chunks::<32>().next().unwrap();
+            let len = local_tail.as_chunks::<32>().0.iter().next().unwrap();
             let len = U256::from_be_bytes(*len);
             let len = u256_to_usize_checked(&len)?;
             let (_, body) = local_tail.split_at_mut_checked(32).ok_or(())?;
diff --git a/supporting_crates/solidity_abi/src/impls/codable_slice.rs b/supporting_crates/solidity_abi/src/impls/codable_slice.rs
@@ -105,14 +105,14 @@ impl<'a, T: SolidityCodable + 'a> SolidityCodableReflectionRef<'a> for SliceRef<
         if local_head.len() < 32 {
             return Err(());
         }
-        let tail_offset = local_head.array_chunks::<32>().next().unwrap();
+        let tail_offset = local_head.as_chunks::<32>().0.iter().next().unwrap();
         let tail_offset = U256::from_be_bytes(*tail_offset);
         let tail_offset = u256_to_usize_checked(&tail_offset)?;
         let (_, local_tail) = source.split_at_checked(tail_offset).ok_or(())?;
         if local_tail.len() < 32 {
             return Err(());
         }
-        let len = local_tail.array_chunks::<32>().next().unwrap();
+        let len = local_tail.as_chunks::<32>().0.iter().next().unwrap();
         let len = U256::from_be_bytes(*len);
         let len = u256_to_usize_checked(&len)?;
         let (_, body) = local_tail.split_at_checked(32).ok_or(())?;
@@ -141,14 +141,14 @@ impl<'a, T: SolidityCodable + 'a> SolidityCodableReflectionRefMut<'a> for SliceR
         if local_head.len() < 32 {
             return Err(());
         }
-        let tail_offset = local_head.array_chunks::<32>().next().unwrap();
+        let tail_offset = local_head.as_chunks::<32>().0.iter().next().unwrap();
         let tail_offset = U256::from_be_bytes(*tail_offset);
         let tail_offset = u256_to_usize_checked(&tail_offset)?;
         let (_, local_tail) = source.split_at_mut_checked(tail_offset).ok_or(())?;
         if local_tail.len() < 32 {
             return Err(());
         }
-        let len = local_tail.array_chunks::<32>().next().unwrap();
+        let len = local_tail.as_chunks::<32>().0.iter().next().unwrap();
         let len = U256::from_be_bytes(*len);
         let len = u256_to_usize_checked(&len)?;
         let (_, body) = local_tail.split_at_mut_checked(32).ok_or(())?;
diff --git a/supporting_crates/solidity_abi/src/impls/string_ref.rs b/supporting_crates/solidity_abi/src/impls/string_ref.rs
@@ -37,14 +37,14 @@ impl<'a> SolidityCodableReflectionRef<'a> for SolidityStringRef<'a> {
         if local_head.len() < 32 {
             return Err(());
         }
-        let tail_offset = local_head.array_chunks::<32>().next().unwrap();
+        let tail_offset = local_head.as_chunks::<32>().0.iter().next().unwrap();
         let tail_offset = U256::from_be_bytes(*tail_offset);
         let tail_offset = u256_to_usize_checked(&tail_offset)?;
         let (_, local_tail) = source.split_at_checked(tail_offset).ok_or(())?;
         if local_tail.len() < 32 {
             return Err(());
         }
-        let len = local_tail.array_chunks::<32>().next().unwrap();
+        let len = local_tail.as_chunks::<32>().0.iter().next().unwrap();
         let len = U256::from_be_bytes(*len);
         let len = u256_to_usize_checked(&len)?;
         let (_, bytes_body) = local_tail.split_at_checked(32).ok_or(())?;
@@ -66,14 +66,14 @@ impl<'a> SolidityCodableReflectionRefMut<'a> for SolidityStringRefMut<'a> {
         if local_head.len() < 32 {
             return Err(());
         }
-        let tail_offset = local_head.array_chunks::<32>().next().unwrap();
+        let tail_offset = local_head.as_chunks::<32>().0.iter().next().unwrap();
         let tail_offset = U256::from_be_bytes(*tail_offset);
         let tail_offset = u256_to_usize_checked(&tail_offset)?;
         let (_, local_tail) = source.split_at_mut_checked(tail_offset).ok_or(())?;
         if local_tail.len() < 32 {
             return Err(());
         }
-        let len = local_tail.array_chunks::<32>().next().unwrap();
+        let len = local_tail.as_chunks::<32>().0.iter().next().unwrap();
         let len = U256::from_be_bytes(*len);
         let len = u256_to_usize_checked(&len)?;
         let (_, bytes_body) = local_tail.split_at_mut_checked(32).ok_or(())?;
diff --git a/supporting_crates/solidity_abi/src/impls/uint_x.rs b/supporting_crates/solidity_abi/src/impls/uint_x.rs
@@ -28,7 +28,7 @@ macro_rules! uint_impl {
                 if local_head.len() < 32 {
                     return Err(());
                 }
-                let source = local_head.array_chunks::<32>().next().unwrap();
+                let source = local_head.as_chunks::<32>().0.iter().next().unwrap();
                 let new = Self { source };
                 *head_offset += 32;
 
@@ -42,7 +42,7 @@ macro_rules! uint_impl {
                 if local_head.len() < 32 {
                     return Err(());
                 }
-                let source = local_head.array_chunks_mut::<32>().next().unwrap();
+                let source = local_head.as_chunks_mut::<32>().0.iter_mut().next().unwrap();
                 let new = Self { source };
                 *head_offset += 32;
 
@@ -137,7 +137,7 @@ impl<'a> SolidityCodableReflectionRef<'a> for AddressRef<'a> {
         if local_head.len() < 32 {
             return Err(());
         }
-        let source = local_head.array_chunks::<32>().next().unwrap();
+        let source = local_head.as_chunks::<32>().0.iter().next().unwrap();
         let new = Self { source };
         *head_offset += 32;
 
@@ -151,7 +151,7 @@ impl<'a> SolidityCodableReflectionRefMut<'a> for AddressRefMut<'a> {
         if local_head.len() < 32 {
             return Err(());
         }
-        let source = local_head.array_chunks_mut::<32>().next().unwrap();
+        let source = local_head.as_chunks_mut::<32>().0.iter_mut().next().unwrap();
         let new = Self { source };
         *head_offset += 32;
 
@@ -241,7 +241,7 @@ impl<'a> SolidityCodableReflectionRefWritable<'a> for AddressRefMut<'a> {
 //         if local_head.len() < 32 {
 //             return Err(());
 //         }
-//         let source = local_head.array_chunks::<32>().next().unwrap();
+//         let source = local_head.as_chunks::<32>().0.iter().next().unwrap();
 //         let new = Self { source };
 //         *head_offset += 32;
 
diff --git a/supporting_crates/solidity_abi/src/lib.rs b/supporting_crates/solidity_abi/src/lib.rs
@@ -1,7 +1,6 @@
 #![cfg_attr(not(test), no_std)]
 #![allow(incomplete_features)]
 #![feature(generic_const_exprs)]
-#![feature(array_chunks)]
 #![feature(allocator_api)]
 #![allow(clippy::result_unit_err)]
 #![allow(clippy::needless_lifetimes)]
diff --git a/system_hooks/src/lib.rs b/system_hooks/src/lib.rs
@@ -1,6 +1,5 @@
 #![cfg_attr(target_arch = "riscv32", no_std)]
 #![feature(allocator_api)]
-#![feature(array_chunks)]
 #![feature(get_mut_unchecked)]
 #![feature(const_type_id)]
 #![feature(vec_push_within_capacity)]
diff --git a/tests/binary_checker/src/lib.rs b/tests/binary_checker/src/lib.rs
@@ -1,5 +1,3 @@
-#![feature(array_chunks)]
-
 #[cfg(test)]
 mod tests {
     use std::{io::Read, path::PathBuf, str::FromStr};
@@ -17,7 +15,9 @@ mod tests {
         assert!(binary.len() % 4 == 0);
 
         binary
-            .array_chunks()
+            .as_chunks()
+            .0
+            .iter()
             .map(|el| u32::from_le_bytes(*el))
             .collect()
     }
diff --git a/tests/instances/eth_runner/src/main.rs b/tests/instances/eth_runner/src/main.rs
@@ -1,4 +1,3 @@
-#![feature(slice_as_array)]
 #![recursion_limit = "1024"]
 
 use clap::{Parser, Subcommand};
diff --git a/tests/rig/src/chain.rs b/tests/rig/src/chain.rs
@@ -851,7 +851,7 @@ fn run_prover(csr_reads: &[u32]) {
     let mut buffer = vec![];
     file.read_to_end(&mut buffer).expect("must read the file");
     let mut binary = vec![];
-    for el in buffer.array_chunks::<4>() {
+    for el in buffer.as_chunks::<4>().0.iter() {
         binary.push(u32::from_le_bytes(*el));
     }
 
diff --git a/tests/rig/src/lib.rs b/tests/rig/src/lib.rs
@@ -1,7 +1,5 @@
 #![allow(incomplete_features)]
-#![feature(generic_const_exprs)]
 #![feature(allocator_api)]
-#![feature(array_chunks)]
 //!
 //! This crate contains infrastructure to write ZKsync OS integration tests.
 //! It contains `Chain` - in memory chain state structure with methods to run blocks, change state
diff --git a/zk_ee/src/common_structs/history_map/element_pool.rs b/zk_ee/src/common_structs/history_map/element_pool.rs
@@ -47,7 +47,7 @@ impl<V, A: Allocator + Clone> ElementPool<V, A> {
         match self.head {
             None => {
                 // Allocate
-                let raw = Box::into_raw(Box::new_in(
+                let (raw, _) = Box::into_raw_with_allocator(Box::new_in(
                     HistoryRecord {
                         touch_ss_id: snapshot_id,
                         value,
diff --git a/zk_ee/src/lib.rs b/zk_ee/src/lib.rs
@@ -1,12 +1,8 @@
 #![cfg_attr(not(feature = "serde"), no_std)]
 #![allow(incomplete_features)]
-#![feature(generic_const_exprs)]
-#![feature(const_type_id)]
 #![feature(allocator_api)]
-#![feature(array_chunks)]
 #![feature(associated_type_defaults)]
 #![feature(get_mut_unchecked)]
-#![feature(array_windows)]
 #![feature(vec_push_within_capacity)]
 #![feature(slice_from_ptr_range)]
 #![feature(never_type)]
diff --git a/zk_ee/src/utils/aligned_buffer.rs b/zk_ee/src/utils/aligned_buffer.rs
diff --git a/zk_ee/src/utils/aligned_vector.rs b/zk_ee/src/utils/aligned_vector.rs
diff --git a/zk_ee/src/utils/mod.rs b/zk_ee/src/utils/mod.rs
diff --git a/zksync_os/reproduce/Dockerfile b/zksync_os/reproduce/Dockerfile
diff --git a/zksync_os/rust-toolchain.toml b/zksync_os/rust-toolchain.toml

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ fn bn254_ecmul_as_system_function_inner<`
`54`	`54`	`dst = src;`
`55`	`55`	`}`
`56`	`56`
`57`		`- let mut it = buffer.array_chunks::<32>();`
	`57`	`+ let mut it = buffer.as_chunks::<32>().0.iter();`
`58`	`58`	`let serialized_result = unsafe {`
`59`	`59`	`let x0 = it.next().unwrap_unchecked();`
`60`	`60`	`let y0 = it.next().unwrap_unchecked();`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ fn bn254_pairing_check_inner<A: Allocator>(`
`85`	`85`	`for (dst, src) in buffer.iter_mut().zip(&mut src_iter) {`
`86`	`86`	`dst = src;`
`87`	`87`	`}`
`88`		`- let mut it = buffer.array_chunks::<32>();`
	`88`	`+ let mut it = buffer.as_chunks::<32>().0.iter();`
`89`	`89`	`unsafe {`
`90`	`90`	`let mut g1_x = *it.next().unwrap_unchecked();`
`91`	`91`	`let mut g1_y = *it.next().unwrap_unchecked();`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ fn p256_verify_as_system_function_inner<`
`70`	`70`	`dst = src;`
`71`	`71`	`}`
`72`	`72`
`73`		`- let mut it = buffer.array_chunks::<32>();`
	`73`	`+ let mut it = buffer.as_chunks::<32>().0.iter();`
`74`	`74`	`let is_valid = unsafe {`
`75`	`75`	`let digest = it.next().unwrap_unchecked();`
`76`	`76`	`let r = it.next().unwrap_unchecked();`