Function snark_verify_batch

wasm/src/programs/execution.rs:248–281

(verifying_keys: Array, inputs: Array, proof: &Proof)

/// @returns {boolean} True if the batch proof is valid, false otherwise
#[wasm_bindgen(js_name = "snarkVerifyBatch")]
pub fn snark_verify_batch(verifying_keys: Array, inputs: Array, proof: &Proof) -> Result<bool, String> {
    if verifying_keys.length() != inputs.length() {
        return Err(format!(
            "Mismatch: {} verifying keys but {} input groups provided. # of input groups must match # of verifying keys.",
            verifying_keys.length(),
            inputs.length()
        ));
    }

    let mut vks_with_inputs = Vec::with_capacity(verifying_keys.length() as usize);

    for i in 0..verifying_keys.length() {
        let vk_str =
            verifying_keys.get(i).as_string().ok_or_else(|| format!("Expected verifying key string at index {i}"))?;
        let vk_native = VerifyingKeyNative::from_str(&vk_str)
            .map_err(|e| format!("Failed to parse verifying key at index {i}: {e}"))?;

        let instances_js = Array::try_from(inputs.get(i))
            .map_err(|_| format!("Expected array of instances for verifying key at index {i}"))?;
        let mut instances = Vec::with_capacity(instances_js.length() as usize);

        for j in 0..instances_js.length() {
            let instance_js = Array::try_from(instances_js.get(j))
                .map_err(|_| format!("Expected array of field element strings at indices ({i}, {j})"))?;
            let fields = parse_field_inputs(&instance_js)?;
            instances.push(fields);
        }

        vks_with_inputs.push((vk_native, instances));
    }

    VerifyingKeyNative::verify_batch("snark_verify_batch", VarunaVersion::V2, vks_with_inputs, proof)
        .map_or(Ok(false), |_| Ok(true))
}

/// Parse an Array of field element strings into a Vec of raw N::Field elements.
pub(crate) fn parse_field_inputs(inputs: &Array) -> Result<Vec<<CurrentNetwork as Environment>::Field>, String> {