feat(abi)!: add an explicit mapping from ABI params to witness indices

crates/nargo/src/cli/execute_cmd.rs

@@ -1,14 +1,14 @@
-use clap::ArgMatches;
 use std::path::{Path, PathBuf};
 
 use acvm::acir::native_types::Witness;
-use acvm::{FieldElement, PartialWitnessGenerator};
+use acvm::PartialWitnessGenerator;
+use clap::ArgMatches;
 use noirc_abi::errors::AbiError;
 use noirc_abi::input_parser::{Format, InputValue};
-use noirc_abi::{Abi, MAIN_RETURN_NAME};
+use noirc_abi::{InputMap, WitnessMap, MAIN_RETURN_NAME};
 use noirc_driver::CompiledProgram;
 
-use super::{create_named_dir, read_inputs_from_file, write_to_file, InputMap, WitnessMap};
+use super::{create_named_dir, read_inputs_from_file, write_to_file};
 use crate::{
     cli::compile_cmd::compile_circuit,
     constants::{PROVER_INPUT_FILE, TARGET_DIR, WITNESS_EXT},
@@ -40,10 +40,6 @@ pub(crate) fn run(args: ArgMatches) -> Result<(), CliError> {
     Ok(())
 }
 
-/// In Barretenberg, the proof system adds a zero witness in the first index,
-/// So when we add witness values, their index start from 1.
-const WITNESS_OFFSET: u32 = 1;
-
 fn execute_with_path<P: AsRef<Path>>(
     program_dir: P,
     show_ssa: bool,
@@ -69,66 +65,32 @@ pub(crate) fn execute_program(
     // Solve the remaining witnesses
     let solved_witness = solve_witness(compiled_program, inputs_map)?;
 
-    let public_inputs = extract_public_inputs(compiled_program, &solved_witness)?;
+    let public_abi = compiled_program.abi.as_ref().unwrap().clone().public_abi();
+    let public_inputs = public_abi.decode_from_witness(&solved_witness)?;
     let return_value = public_inputs.get(MAIN_RETURN_NAME).cloned();
 
     Ok((return_value, solved_witness))
 }
 
-pub(crate) fn extract_public_inputs(
-    compiled_program: &CompiledProgram,
-    solved_witness: &WitnessMap,
-) -> Result<InputMap, AbiError> {
-    let encoded_public_inputs: Vec<FieldElement> = compiled_program
-        .circuit
-        .public_inputs
-        .0
-        .iter()
-        .map(|index| solved_witness[index])
-        .collect();
-
-    let public_abi = compiled_program.abi.as_ref().unwrap().clone().public_abi();
-
-    public_abi.decode(&encoded_public_inputs)
-}
-
 pub(crate) fn solve_witness(
     compiled_program: &CompiledProgram,
     input_map: &InputMap,
 ) -> Result<WitnessMap, CliError> {
-    let abi = compiled_program.abi.as_ref().unwrap().clone();
-    let mut solved_witness =
-        input_map_to_witness_map(abi, input_map).map_err(|error| match error {
-            AbiError::UndefinedInput(_) => {
-                CliError::Generic(format!("{error} in the {PROVER_INPUT_FILE}.toml file."))
-            }
-            _ => CliError::from(error),
-        })?;
+    let abi = compiled_program.abi.as_ref().unwrap();
+
+    let mut solved_witness = abi.encode_to_witness(input_map).map_err(|error| match error {
+        AbiError::UndefinedInput(_) => {
+            CliError::Generic(format!("{error} in the {PROVER_INPUT_FILE}.toml file."))
+        }
+        _ => CliError::from(error),
+    })?;
 
     let backend = crate::backends::ConcreteBackend;
     backend.solve(&mut solved_witness, compiled_program.circuit.opcodes.clone())?;
 
     Ok(solved_witness)
 }
 
-/// Given an InputMap and an Abi, produce a WitnessMap
-///
-/// In particular, this method shows one how to associate values in a Toml/JSON
-/// file with witness indices
-fn input_map_to_witness_map(abi: Abi, input_map: &InputMap) -> Result<WitnessMap, AbiError> {
-    // The ABI map is first encoded as a vector of field elements
-    let encoded_inputs = abi.encode(input_map, true)?;
-
-    Ok(encoded_inputs
-        .into_iter()
-        .enumerate()
-        .map(|(index, witness_value)| {
-            let witness = Witness::new(WITNESS_OFFSET + (index as u32));
-            (witness, witness_value)
-        })
-        .collect())
-}
-
 pub(crate) fn save_witness_to_dir<P: AsRef<Path>>(
     witness: WitnessMap,
     witness_name: &str,

crates/nargo/src/cli/mod.rs

@@ -1,18 +1,12 @@
-use acvm::{
-    acir::{circuit::PublicInputs, native_types::Witness},
-    FieldElement,
-};
+use acvm::{acir::circuit::PublicInputs, FieldElement};
 pub use check_cmd::check_from_path;
 use clap::{App, AppSettings, Arg};
 use const_format::formatcp;
-use noirc_abi::{
-    input_parser::{Format, InputValue},
-    Abi,
-};
+use noirc_abi::{input_parser::Format, Abi, InputMap};
 use noirc_driver::Driver;
 use noirc_frontend::graph::{CrateName, CrateType};
 use std::{
-    collections::{BTreeMap, HashMap, HashSet},
+    collections::{HashMap, HashSet},
     fs::File,
     io::Write,
     path::{Path, PathBuf},
@@ -39,12 +33,6 @@ const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
 static VERSION_STRING: &str =
     formatcp!("{} (git version hash: {}, is dirty: {})", CARGO_PKG_VERSION, GIT_HASH, IS_DIRTY);
 
-/// A map from the fields in an TOML/JSON file which correspond to some ABI to their values
-pub type InputMap = BTreeMap<String, InputValue>;
-
-/// A map from the witnesses in a constraint system to the field element values
-pub type WitnessMap = BTreeMap<Witness, FieldElement>;
-
 pub fn start_cli() {
     let allow_warnings = Arg::with_name("allow-warnings")
         .long("allow-warnings")

crates/nargo/src/cli/prove_cmd.rs

@@ -9,10 +9,7 @@ use super::{
     write_to_file,
 };
 use crate::{
-    cli::{
-        execute_cmd::{execute_program, extract_public_inputs},
-        verify_cmd::verify_proof,
-    },
+    cli::{execute_cmd::execute_program, verify_cmd::verify_proof},
     constants::{PROOFS_DIR, PROOF_EXT, PROVER_INPUT_FILE, VERIFIER_INPUT_FILE},
     errors::CliError,
 };
@@ -57,7 +54,8 @@ pub fn prove_with_path<P: AsRef<Path>>(
     let (_, solved_witness) = execute_program(&compiled_program, &inputs_map)?;
 
     // Write public inputs into Verifier.toml
-    let public_inputs = extract_public_inputs(&compiled_program, &solved_witness)?;
+    let public_abi = compiled_program.abi.as_ref().unwrap().clone().public_abi();
+    let public_inputs = public_abi.decode_from_witness(&solved_witness)?;
     write_inputs_to_file(&public_inputs, &program_dir, VERIFIER_INPUT_FILE, Format::Toml)?;
 
     // Since the public outputs are added onto the public inputs list, there can be duplicates.

crates/nargo/src/cli/verify_cmd.rs

@@ -64,7 +64,7 @@ pub(crate) fn verify_proof(
 ) -> Result<bool, CliError> {
     let public_abi = compiled_program.abi.unwrap().public_abi();
     let public_inputs =
-        public_abi.encode(&public_inputs_map, false).map_err(|error| match error {
+        public_abi.encode_to_array(&public_inputs_map).map_err(|error| match error {
             AbiError::UndefinedInput(_) => {
                 CliError::Generic(format!("{error} in the {VERIFIER_INPUT_FILE}.toml file."))
             }

crates/noirc_abi/src/lib.rs

@@ -1,10 +1,10 @@
 #![forbid(unsafe_code)]
 use std::{collections::BTreeMap, convert::TryInto, str};
 
-use acvm::FieldElement;
+use acvm::{acir::native_types::Witness, FieldElement};
 use errors::AbiError;
 use input_parser::InputValue;
-use iter_extended::vecmap;
+use iter_extended::{try_btree_map, vecmap};
 use serde::{Deserialize, Serialize};
 // This is the ABI used to bridge the different TOML formats for the initial
 // witness, the partial witness generator and the interpreter.
@@ -15,6 +15,12 @@ pub mod errors;
 pub mod input_parser;
 mod serialization;
 
+/// A map from the fields in an TOML/JSON file which correspond to some ABI to their values
+pub type InputMap = BTreeMap<String, InputValue>;
+
+/// A map from the witnesses in a constraint system to the field element values
+pub type WitnessMap = BTreeMap<Witness, FieldElement>;
+
 pub const MAIN_RETURN_NAME: &str = "return";
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -120,6 +126,7 @@ impl AbiParameter {
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Abi {
     pub parameters: Vec<AbiParameter>,
+    pub param_witnesses: BTreeMap<String, Vec<Witness>>,
 }
 
 impl Abi {
@@ -149,52 +156,89 @@ impl Abi {
     pub fn public_abi(self) -> Abi {
         let parameters: Vec<_> =
             self.parameters.into_iter().filter(|param| param.is_public()).collect();
-        Abi { parameters }
+        let param_witnesses = self
+            .param_witnesses
+            .into_iter()
+            .filter(|(param_name, _)| parameters.iter().any(|param| &param.name == param_name))
+            .collect();
+        Abi { parameters, param_witnesses }
+    }
+
+    /// Encode a set of inputs as described in the ABI into a `WitnessMap`.
+    pub fn encode_to_witness(&self, input_map: &InputMap) -> Result<WitnessMap, AbiError> {
+        self.check_for_unexpected_inputs(input_map)?;
+
+        // First encode each input separately, performing any input validation.
+        let encoded_input_map: BTreeMap<String, Vec<FieldElement>> = self
+            .to_btree_map()
+            .into_iter()
+            .filter(|(param_name, _)| param_name != MAIN_RETURN_NAME)
+            .map(|(param_name, expected_type)| {
+                let value = input_map
+                    .get(&param_name)
+                    .ok_or_else(|| AbiError::MissingParam(param_name.clone()))?
+                    .clone();
+
+                if !value.matches_abi(&expected_type) {
+                    let missing_param = self
+                        .parameters
+                        .iter()
+                        .find(|param| param.name == param_name)
+                        .unwrap()
+                        .clone();
+                    return Err(AbiError::TypeMismatch { param: missing_param, value });
+                }
+
+                Self::encode_value(value, &param_name).map(|v| (param_name, v))
+            })
+            .collect::<Result<_, _>>()?;
+
+        // Write input field elements into witness indices specified in `self.param_witnesses`.
+        let witness_map = encoded_input_map
+            .iter()
+            .flat_map(|(param_name, encoded_param_fields)| {
+                let param_witness_indices = &self.param_witnesses[param_name];
+                param_witness_indices
+                    .iter()
+                    .zip(encoded_param_fields.iter())
+                    .map(|(&witness, &field_element)| (witness, field_element))
+            })
+            .collect();
+
+        Ok(witness_map)
     }
 
     /// Encode a set of inputs as described in the ABI into a vector of `FieldElement`s.
-    pub fn encode(
-        self,
-        inputs: &BTreeMap<String, InputValue>,
-        skip_output: bool,
-    ) -> Result<Vec<FieldElement>, AbiError> {
-        // Condition that specifies whether we should filter the "return"
-        // parameter. We do this in the case that it is not in the `inputs`
-        // map specified.
-        //
-        // See Issue #645 : Adding a `public outputs` field into acir and
-        // the ABI will clean up this logic
-        // For prosperity; the prover does not know about a `return` value
-        // so we skip this when encoding the ABI
-        let return_condition =
-            |param_name: &&String| !skip_output || (param_name != &MAIN_RETURN_NAME);
-
-        let parameters = self.parameters.iter().filter(|param| return_condition(&&param.name));
-        let param_names: Vec<&String> = parameters.clone().map(|param| &param.name).collect();
-        let mut encoded_inputs = Vec::new();
+    pub fn encode_to_array(self, inputs: &InputMap) -> Result<Vec<FieldElement>, AbiError> {
+        self.check_for_unexpected_inputs(inputs)?;
 
-        for param in parameters {
+        let mut encoded_inputs = Vec::new();
+        for param in &self.parameters {
             let value = inputs
                 .get(&param.name)
                 .ok_or_else(|| AbiError::MissingParam(param.name.to_owned()))?
                 .clone();
 
             if !value.matches_abi(&param.typ) {
-                return Err(AbiError::TypeMismatch { param: param.to_owned(), value });
+                return Err(AbiError::TypeMismatch { param: param.clone(), value });
             }
 
             encoded_inputs.extend(Self::encode_value(value, &param.name)?);
         }
 
-        // Check that no extra witness values have been provided.
-        // Any missing values should be caught by the above for-loop so this only catches extra values.
-        if param_names.len() != inputs.len() {
+        Ok(encoded_inputs)
+    }
+
+    /// Checks that no extra witness values have been provided.
+    fn check_for_unexpected_inputs(&self, inputs: &InputMap) -> Result<(), AbiError> {
+        let param_names = self.parameter_names();
+        if param_names.len() < inputs.len() {
             let unexpected_params: Vec<String> =
                 inputs.keys().filter(|param| !param_names.contains(param)).cloned().collect();
             return Err(AbiError::UnexpectedParams(unexpected_params));
         }
 
-        Ok(encoded_inputs)
+        Ok(())
     }
 
     fn encode_value(value: InputValue, param_name: &String) -> Result<Vec<FieldElement>, AbiError> {
@@ -218,11 +262,24 @@ impl Abi {
         Ok(encoded_value)
     }
 
+    /// Decode a `WitnessMap` into the types specified in the ABI.
+    pub fn decode_from_witness(&self, witness_map: &WitnessMap) -> Result<InputMap, AbiError> {
+        let public_inputs_map =
+            try_btree_map(self.parameters.clone(), |AbiParameter { name, typ, .. }| {
+                let param_witness_values =
+                    vecmap(self.param_witnesses[&name].clone(), |witness_index| {
+                        witness_map[&witness_index]
+                    });
+
+                Self::decode_value(&mut param_witness_values.into_iter(), &typ)
+                    .map(|input_value| (name.clone(), input_value))
+            })?;
+
+        Ok(public_inputs_map)
+    }
+
     /// Decode a vector of `FieldElements` into the types specified in the ABI.
-    pub fn decode(
-        &self,
-        encoded_inputs: &[FieldElement],
-    ) -> Result<BTreeMap<String, InputValue>, AbiError> {
+    pub fn decode_from_array(&self, encoded_inputs: &[FieldElement]) -> Result<InputMap, AbiError> {
         let input_length: u32 = encoded_inputs.len().try_into().unwrap();
         if input_length != self.field_count() {
             return Err(AbiError::UnexpectedInputLength {