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/input_parser/mod.rs

@@ -10,6 +10,7 @@ use crate::{Abi, AbiType};
 /// This is what all formats eventually transform into
 /// For example, a toml file will parse into TomlTypes
 /// and those TomlTypes will be mapped to Value
+#[cfg_attr(test, derive(PartialEq))]
 #[derive(Debug, Clone, Serialize)]
 pub enum InputValue {
     Field(FieldElement),