Use std::array::each_ref instead of std::array::from_fn

This guarantee the source and destination have the same length

ledger/src/account/conv.rs

@@ -8,7 +8,7 @@ use mina_p2p_messages::{
     binprot,
     pseq::PaddedSeq,
     v2::{
-        MinaBaseAccountBinableArgStableV2, MinaBaseAccountIdDigestStableV1,
+        self, MinaBaseAccountBinableArgStableV2, MinaBaseAccountIdDigestStableV1,
         MinaBaseAccountIdStableV2, MinaBaseAccountIndexStableV1, MinaBaseAccountTimingStableV2,
         MinaBasePermissionsAuthRequiredStableV2, MinaBasePermissionsStableV2,
         MinaBaseVerificationKeyWireStableV1, MinaBaseVerificationKeyWireStableV1WrapIndex,
@@ -115,15 +115,15 @@ where
     T: 'a,
     U: From<&'a T>,
 {
-    std::array::from_fn(|i| U::from(&value[i]))
+    value.each_ref().map(|value| U::from(value))
 }
 
 pub fn array_into_with<'a, T, U, F, const N: usize>(value: &'a [T; N], fun: F) -> [U; N]
 where
     T: 'a,
     F: Fn(&T) -> U,
 {
-    std::array::from_fn(|i| fun(&value[i]))
+    value.each_ref().map(|value| fun(value))
 }
 
 impl From<&MinaBaseVerificationKeyWireStableV1> for VerificationKey {
@@ -509,16 +509,24 @@ impl From<&MinaBaseAccountBinableArgStableV2> for Account {
             timing: (&acc.timing).into(),
             permissions: (&acc.permissions).into(),
             zkapp: acc.zkapp.as_ref().map(|zkapp| {
-                let app_state = std::array::from_fn(|i| zkapp.app_state[i].to_field());
+                let v2::MinaBaseZkappAccountStableV2 {
+                    app_state,
+                    verification_key,
+                    zkapp_version,
+                    action_state,
+                    last_action_slot,
+                    proved_state,
+                    zkapp_uri,
+                } = zkapp;
 
                 ZkAppAccount {
-                    app_state,
-                    verification_key: zkapp.verification_key.as_ref().map(Into::into),
-                    zkapp_version: zkapp.zkapp_version.as_u32(),
-                    action_state: std::array::from_fn(|i| zkapp.action_state[i].to_field()),
-                    last_action_slot: Slot::from_u32(zkapp.last_action_slot.as_u32()),
-                    proved_state: zkapp.proved_state,
-                    zkapp_uri: (&zkapp.zkapp_uri).try_into().unwrap(),
+                    app_state: app_state.each_ref().map(|s| s.to_field()),
+                    verification_key: verification_key.as_ref().map(Into::into),
+                    zkapp_version: zkapp_version.as_u32(),
+                    action_state: action_state.each_ref().map(|s| s.to_field()),
+                    last_action_slot: Slot::from_u32(last_action_slot.as_u32()),
+                    proved_state: *proved_state,
+                    zkapp_uri: zkapp_uri.try_into().unwrap(),
                 }
             }),
         }

ledger/src/proofs/accumulator_check.rs

@@ -1,5 +1,3 @@
-use std::array;
-
 use mina_curves::pasta::Vesta;
 use mina_hasher::Fp;
 use mina_p2p_messages::{bigint::BigInt, v2::PicklesProofProofsVerified2ReprStableV2};
@@ -23,7 +21,7 @@ pub fn accumulator_check(
         .iter()
         .map(|chal| {
             let prechallenge = &chal.prechallenge.inner;
-            let prechallenge: [u64; 2] = array::from_fn(|k| prechallenge[k].as_u64());
+            let prechallenge: [u64; 2] = prechallenge.each_ref().map(|c| c.as_u64());
 
             ScalarChallenge::limbs_to_field(&prechallenge)
         })

ledger/src/proofs/block.rs

@@ -702,8 +702,8 @@ mod vrf {
     pub const VRF_OUTPUT_NBITS: usize = 253;
 
     fn truncate_vrf_output(output: Fp, w: &mut Witness<Fp>) -> Box<[bool; VRF_OUTPUT_NBITS]> {
-        let output = w.exists(field_to_bits::<_, 255>(output));
-        Box::new(std::array::from_fn(|i| output[i]))
+        let output: [bool; 255] = w.exists(field_to_bits(output));
+        Box::new(std::array::from_fn(|i| output[i])) // 2 last bits are ignored
     }
 
     pub fn check(

ledger/src/proofs/caching.rs

@@ -328,7 +328,7 @@ impl From<&VerifierIndex<Pallas>> for VerifierIndexCached {
             foreign_field_mul_comm: foreign_field_mul_comm.clone(),
             xor_comm: xor_comm.clone(),
             rot_comm: rot_comm.clone(),
-            shift: std::array::from_fn(|i| shift[i].into()),
+            shift: shift.each_ref().map(|s| s.into()),
             zkpm: zkpm.get().unwrap().into(),
             w: (*w.get().unwrap()).into(),
             endo: endo.into(),
@@ -384,7 +384,7 @@ impl From<&VerifierIndexCached> for VerifierIndex<Pallas> {
             endomul_scalar_comm: endomul_scalar_comm.clone(),
             foreign_field_add_comm: foreign_field_add_comm.clone(),
             xor_comm: xor_comm.clone(),
-            shift: std::array::from_fn(|i| shift[i].to_field()),
+            shift: shift.each_ref().map(|s| s.to_field()),
             zkpm: OnceCell::with_value(zkpm.into()),
             w: OnceCell::with_value(w.to_field()),
             endo: endo.to_field(),

ledger/src/proofs/merge.rs

@@ -113,10 +113,12 @@ impl<F: FieldWitness>
             feature_flags: _, // TODO: Handle features flags
         } = value;
 
-        let alpha_bytes = std::array::from_fn(|i| alpha.inner[i].as_u64());
-        let beta_bytes = std::array::from_fn(|i| beta[i].as_u64());
-        let gamma_bytes = std::array::from_fn(|i| gamma[i].as_u64());
-        let zeta_bytes = std::array::from_fn(|i| zeta.inner[i].as_u64());
+        let to_bytes = |v: &v2::LimbVectorConstantHex64StableV1| v.as_u64();
+
+        let alpha_bytes = alpha.inner.each_ref().map(to_bytes);
+        let beta_bytes = beta.each_ref().map(to_bytes);
+        let gamma_bytes = gamma.each_ref().map(to_bytes);
+        let zeta_bytes = zeta.inner.each_ref().map(to_bytes);
 
         assert!(joint_combiner.is_none());
 

ledger/src/proofs/prover.rs

@@ -1,4 +1,4 @@
-use std::{array, borrow::Cow, str::FromStr};
+use std::{borrow::Cow, str::FromStr};
 
 use kimchi::{
     poly_commitment::PolyComm,
@@ -46,10 +46,8 @@ pub fn make_padded_proof_from_p2p(
         shifted: None,
     };
 
-    let w_comm: [PolyComm<Pallas>; 15] =
-        array::from_fn(|i| make_poly(&proof.commitments.w_comm[i]));
+    let w_comm: [PolyComm<Pallas>; 15] = proof.commitments.w_comm.each_ref().map(make_poly);
     let z_comm: PolyComm<Pallas> = make_poly(&proof.commitments.z_comm);
-    // let t_comm: [PolyComm<Pallas>; 7] = array::from_fn(|i| make_poly(&proof.commitments.t_comm[i]));
     let t_comm: PolyComm<Pallas> = {
         let unshifted = proof.commitments.t_comm.iter().map(of_coord).collect();
         PolyComm {
@@ -84,12 +82,12 @@ pub fn make_padded_proof_from_p2p(
     };
 
     let evals: ProofEvaluations<PointEvaluations<Vec<Fq>>> = ProofEvaluations {
-        w: array::from_fn(|i| to_pt_eval(&evals.w[i])),
+        w: evals.w.each_ref().map(to_pt_eval),
         z: to_pt_eval(&evals.z),
-        s: array::from_fn(|i| to_pt_eval(&evals.s[i])),
+        s: evals.s.each_ref().map(to_pt_eval),
         generic_selector: to_pt_eval(&evals.generic_selector),
         poseidon_selector: to_pt_eval(&evals.poseidon_selector),
-        coefficients: array::from_fn(|i| to_pt_eval(&evals.coefficients[i])),
+        coefficients: evals.coefficients.each_ref().map(to_pt_eval),
         complete_add_selector: to_pt_eval(&evals.complete_add_selector),
         mul_selector: to_pt_eval(&evals.mul_selector),
         emul_selector: to_pt_eval(&evals.emul_selector),

ledger/src/proofs/public_input/messages.rs

@@ -17,8 +17,8 @@ impl<'a> From<&'a VerifierIndex<Pallas>> for PlonkVerificationKeyEvals<Fp> {
         let to_curve = |v: &PolyComm<Pallas>| InnerCurve::of_affine(v.unshifted[0]);
 
         Self {
-            sigma: std::array::from_fn(|i| to_curve(&verifier_index.sigma_comm[i])),
-            coefficients: std::array::from_fn(|i| to_curve(&verifier_index.coefficients_comm[i])),
+            sigma: verifier_index.sigma_comm.each_ref().map(to_curve),
+            coefficients: verifier_index.coefficients_comm.each_ref().map(to_curve),
             generic: to_curve(&verifier_index.generic_comm),
             psm: to_curve(&verifier_index.psm_comm),
             complete_add: to_curve(&verifier_index.complete_add_comm),

ledger/src/proofs/public_input/scalar_challenge.rs

@@ -95,7 +95,7 @@ impl ScalarChallenge {
 
     pub fn array_to_fields<F: FieldWitness, const N: usize>(array: &[F; N]) -> [F; N] {
         let (_, endo) = endos::<F::Scalar>();
-        std::array::from_fn(|i| Self::from(array[i]).to_field(&endo))
+        array.each_ref().map(|v| Self::from(*v).to_field(&endo))
     }
 
     pub fn limbs_to_field<F: FieldWitness>(limbs: &[u64; 2]) -> F {

ledger/src/proofs/step.rs

@@ -209,28 +209,24 @@ impl From<&v2::PicklesProofProofsVerified2ReprStableV2StatementProofState> for S
         Self {
             deferred_values: StatementDeferredValues {
                 plonk: plonk.into(),
-                bulletproof_challenges: std::array::from_fn(|i| {
-                    std::array::from_fn(|j| {
-                        bulletproof_challenges[i].prechallenge.inner[j].as_u64()
-                    })
-                }),
+                bulletproof_challenges: bulletproof_challenges
+                    .each_ref()
+                    .map(|challenge| challenge.prechallenge.inner.each_ref().map(|v| v.as_u64())),
                 branch_data: branch_data.clone(),
             },
-            sponge_digest_before_evaluations: std::array::from_fn(|i| {
-                sponge_digest_before_evaluations[i].as_u64()
-            }),
+            sponge_digest_before_evaluations: sponge_digest_before_evaluations
+                .each_ref()
+                .map(|v| v.as_u64()),
             messages_for_next_wrap_proof: MessagesForNextWrapProof {
                 challenge_polynomial_commitment: InnerCurve::from((
                     c0.to_field::<Fq>(),
                     c1.to_field(),
                 )),
                 old_bulletproof_challenges: old_bulletproof_challenges
                     .iter()
-                    .map(|v| {
-                        std::array::from_fn(|i| {
-                            u64_to_field::<_, 2>(&std::array::from_fn(|j| {
-                                v.0[i].prechallenge.inner[j].as_u64()
-                            }))
+                    .map(|old_bulletproof_challenge| {
+                        old_bulletproof_challenge.each_ref().map(|chal| {
+                            u64_to_field(&chal.prechallenge.inner.each_ref().map(|v| v.as_u64()))
                         })
                     })
                     .collect(),
@@ -2101,17 +2097,17 @@ fn expand_proof(params: ExpandProofParams) -> ExpandedProof {
                     .deferred_values
                     .bulletproof_challenges
                     .iter()
-                    .map(|v| {
-                        u64_to_field::<_, 2>(&std::array::from_fn(|i| {
-                            v.prechallenge.inner[i].as_u64()
-                        }))
+                    .map(|challenge| {
+                        u64_to_field(&challenge.prechallenge.inner.each_ref().map(|v| v.as_u64()))
                     })
                     .collect(),
                 branch_data: deferred_values.branch_data,
             },
-            sponge_digest_before_evaluations: std::array::from_fn(|i| {
-                statement.proof_state.sponge_digest_before_evaluations[i].as_u64()
-            }),
+            sponge_digest_before_evaluations: statement
+                .proof_state
+                .sponge_digest_before_evaluations
+                .each_ref()
+                .map(|v| v.as_u64()),
             messages_for_next_wrap_proof: MessagesForNextWrapProof {
                 old_bulletproof_challenges: prev_challenges.clone(),
                 challenge_polynomial_commitment: {
@@ -2473,9 +2469,8 @@ pub fn extract_recursion_challenges<const N: usize>(
 ) -> Vec<RecursionChallenge<GroupAffine<Fq>>> {
     use poly_commitment::PolyComm;
 
-    let comms: [(Fq, Fq); N] = std::array::from_fn(|i| {
-        let p = &proofs[i];
-        let (a, b) = &p
+    let comms: [(Fq, Fq); N] = proofs.map(|proof| {
+        let (a, b) = &proof
             .statement
             .proof_state
             .messages_for_next_wrap_proof
@@ -2582,15 +2577,15 @@ pub fn step<C: ProofConstants, const N_PREVIOUS: usize>(
         .unwrap();
 
     let prevs: [&PerProofWitness; N_PREVIOUS] =
-        w.exists(std::array::from_fn(|i| &expanded_proofs[i].witness));
+        w.exists(expanded_proofs.each_ref().map(|p| &p.witness));
     let unfinalized_proofs_unextended: [&Unfinalized; N_PREVIOUS] =
-        w.exists(std::array::from_fn(|i| &expanded_proofs[i].unfinalized));
+        w.exists(expanded_proofs.each_ref().map(|p| &p.unfinalized));
 
     let messages_for_next_wrap_proof: [Fp; N_PREVIOUS] = {
         let f = u64_to_field::<Fp, 4>;
-        std::array::from_fn(|i| {
-            f(&expanded_proofs[i]
-                .prev_statement_with_hashes
+
+        expanded_proofs.each_ref().map(|p| {
+            f(&p.prev_statement_with_hashes
                 .proof_state
                 .messages_for_next_wrap_proof)
         })
@@ -2611,7 +2606,7 @@ pub fn step<C: ProofConstants, const N_PREVIOUS: usize>(
         let all_possible_domains = wrap_verifier::all_possible_domains();
 
         let actuals_wrap_domain: [u32; N_PREVIOUS] =
-            std::array::from_fn(|i| expanded_proofs[i].actual_wrap_domain);
+            expanded_proofs.each_ref().map(|p| p.actual_wrap_domain);
 
         actuals_wrap_domain.map(|domain_size| {
             let domain_size = domain_size as u64;
@@ -2715,8 +2710,10 @@ pub fn step<C: ProofConstants, const N_PREVIOUS: usize>(
         w,
     )?;
 
-    let proofs: [&v2::PicklesProofProofsVerified2ReprStableV2; N_PREVIOUS] =
-        std::array::from_fn(|i| rule.previous_proof_statements[i].proof);
+    let proofs: [&v2::PicklesProofProofsVerified2ReprStableV2; N_PREVIOUS] = rule
+        .previous_proof_statements
+        .each_ref()
+        .map(|stmt| stmt.proof);
 
     let prev_evals = proofs
         .iter()
@@ -2757,7 +2754,7 @@ pub fn step<C: ProofConstants, const N_PREVIOUS: usize>(
 
     let old_bulletproof_challenges = old_bulletproof_challenges
         .into_iter()
-        .map(|v: [[u64; 2]; 16]| std::array::from_fn(|i| u64_to_field::<Fp, 2>(&v[i])))
+        .map(|v: [[u64; 2]; 16]| v.each_ref().map(u64_to_field))
         .collect();
 
     let step_statement = crate::proofs::transaction::StepStatement {

ledger/src/proofs/transaction.rs

@@ -523,18 +523,17 @@ impl CircuitPlonkVerificationKeyEvals<Fp> {
             endomul_scalar,
         } = self;
 
-        use std::array;
-        let c = |c: &GroupAffine<Fp>| InnerCurve::<Fp>::of_affine(*c);
+        let c = |c: &CircuitVar<GroupAffine<Fp>>| InnerCurve::<Fp>::of_affine(*c.value());
 
         PlonkVerificationKeyEvals::<Fp> {
-            sigma: array::from_fn(|i| c(sigma[i].value())),
-            coefficients: array::from_fn(|i| c(coefficients[i].value())),
-            generic: c(generic.value()),
-            psm: c(psm.value()),
-            complete_add: c(&complete_add.value()),
-            mul: c(&mul.value()),
-            emul: c(&emul.value()),
-            endomul_scalar: c(&endomul_scalar.value()),
+            sigma: sigma.each_ref().map(c),
+            coefficients: coefficients.each_ref().map(c),
+            generic: c(generic),
+            psm: c(psm),
+            complete_add: c(complete_add),
+            mul: c(mul),
+            emul: c(emul),
+            endomul_scalar: c(endomul_scalar),
         }
     }
 }
@@ -555,12 +554,11 @@ impl PlonkVerificationKeyEvals<Fp> {
             endomul_scalar,
         } = self;
 
-        use std::array;
         let cvar = |c: &InnerCurve<Fp>| cvar(c.to_affine());
 
         CircuitPlonkVerificationKeyEvals::<Fp> {
-            sigma: array::from_fn(|i| cvar(&sigma[i])),
-            coefficients: array::from_fn(|i| cvar(&coefficients[i])),
+            sigma: sigma.each_ref().map(cvar),
+            coefficients: coefficients.each_ref().map(cvar),
             generic: cvar(&generic),
             psm: cvar(&psm),
             complete_add: cvar(&complete_add),

ledger/src/proofs/unfinalized.rs

@@ -195,10 +195,10 @@ pub fn evals_from_p2p<F: FieldWitness>(
 
     use std::array;
     ProofEvaluations {
-        w: array::from_fn(|i| of(&w[i])),
+        w: w.each_ref().map(of),
         z: of(z),
-        s: array::from_fn(|i| of(&s[i])),
-        coefficients: array::from_fn(|i| of(&coefficients[i])),
+        s: s.each_ref().map(of),
+        coefficients: coefficients.each_ref().map(of),
         generic_selector: of(generic_selector),
         poseidon_selector: of(poseidon_selector),
         complete_add_selector: of(complete_add_selector),
@@ -288,7 +288,7 @@ pub fn dummy_ipa_step_challenges() -> [[u64; 2]; BACKEND_TICK_ROUNDS_N] {
 pub fn dummy_ipa_step_challenges_computed() -> [Fp; BACKEND_TICK_ROUNDS_N] {
     cache_one!([Fp; BACKEND_TICK_ROUNDS_N], {
         let challenges = dummy_ipa_step_challenges();
-        std::array::from_fn(|i| ScalarChallenge::limbs_to_field(&challenges[i]))
+        challenges.each_ref().map(ScalarChallenge::limbs_to_field)
     })
 }
 

ledger/src/proofs/util.rs

@@ -1,5 +1,3 @@
-use std::array;
-
 use ark_ff::{BigInteger256, Field};
 use kimchi::proof::ProofEvaluations;
 use mina_hasher::Fp;
@@ -45,9 +43,8 @@ pub fn extract_bulletproof<
 ) -> Vec<[F; N]> {
     v.into_iter()
         .map(|old| {
-            array::from_fn(|j| {
-                let prechallenge = &old[j].prechallenge.inner;
-                let prechallenge: [u64; 2] = array::from_fn(|k| prechallenge[k].as_u64());
+            old.each_ref().map(|old| {
+                let prechallenge = old.prechallenge.inner.each_ref().map(|v| v.as_u64());
                 ScalarChallenge::limbs_to_field(&prechallenge)
             })
         })