Returned values from main are set to public (Successor)

crates/nargo/src/cli/mod.rs

@@ -1,3 +1,4 @@
+use acvm::{acir::circuit::PublicInputs, FieldElement};
 pub use check_cmd::check_from_path;
 use clap::{App, AppSettings, Arg};
 use const_format::formatcp;
@@ -9,7 +10,7 @@ use noirc_abi::{
 use noirc_driver::Driver;
 use noirc_frontend::graph::{CrateName, CrateType};
 use std::{
-    collections::BTreeMap,
+    collections::{BTreeMap, HashMap, HashSet},
     fs::File,
     io::Write,
     path::{Path, PathBuf},
@@ -206,6 +207,44 @@ fn path_to_stdlib() -> PathBuf {
     dirs::config_dir().unwrap().join("noir-lang").join("std/src")
 }
 
+// Removes duplicates from the list of public input witnesses
+fn dedup_public_input_indices(indices: PublicInputs) -> PublicInputs {
+    let duplicates_removed: HashSet<_> = indices.0.into_iter().collect();
+    PublicInputs(duplicates_removed.into_iter().collect())
+}
+
+// Removes duplicates from the list of public input witnesses and the
+// associated list of duplicate values.
+pub(crate) fn dedup_public_input_indices_values(
+    indices: PublicInputs,
+    values: Vec<FieldElement>,
+) -> (PublicInputs, Vec<FieldElement>) {
+    // Assume that the public input index lists and the values contain duplicates
+    assert_eq!(indices.0.len(), values.len());
+
+    let mut public_inputs_without_duplicates = Vec::new();
+    let mut already_seen_public_indices = HashMap::new();
+
+    for (index, value) in indices.0.iter().zip(values) {
+        match already_seen_public_indices.get(index) {
+            Some(expected_value) => {
+                // The index has already been added
+                // so lets check that the values already inserted is equal to the value, we wish to insert
+                assert_eq!(*expected_value, value, "witness index {index:?} does not have a canonical map. The expected value is {expected_value}, the received value is {value}.")
+            }
+            None => {
+                already_seen_public_indices.insert(*index, value);
+                public_inputs_without_duplicates.push(value)
+            }
+        }
+    }
+
+    (
+        PublicInputs(already_seen_public_indices.keys().copied().collect()),
+        public_inputs_without_duplicates,
+    )
+}
+
 // FIXME: I not sure that this is the right place for this tests.
 #[cfg(test)]
 mod tests {

crates/nargo/src/cli/prove_cmd.rs

@@ -1,15 +1,17 @@
-use std::{collections::BTreeMap, path::PathBuf};
-
 use acvm::acir::native_types::Witness;
 use acvm::FieldElement;
 use acvm::PartialWitnessGenerator;
 use acvm::ProofSystemCompiler;
 use clap::ArgMatches;
 use noirc_abi::errors::AbiError;
 use noirc_abi::input_parser::{Format, InputValue};
-use std::path::Path;
+use std::{
+    collections::BTreeMap,
+    path::{Path, PathBuf},
+};
 
 use super::{create_named_dir, read_inputs_from_file, write_inputs_to_file, write_to_file};
+use crate::cli::dedup_public_input_indices;
 use crate::{
     constants::{PROOFS_DIR, PROOF_EXT, PROVER_INPUT_FILE, VERIFIER_INPUT_FILE},
     errors::CliError,
@@ -69,12 +71,20 @@ pub fn compile_circuit_and_witness<P: AsRef<Path>>(
     show_ssa: bool,
     allow_unused_variables: bool,
 ) -> Result<(noirc_driver::CompiledProgram, BTreeMap<Witness, FieldElement>), CliError> {
-    let compiled_program = super::compile_cmd::compile_circuit(
+    let mut compiled_program = super::compile_cmd::compile_circuit(
         program_dir.as_ref(),
         show_ssa,
         allow_unused_variables,
     )?;
     let solved_witness = parse_and_solve_witness(program_dir, &compiled_program)?;
+
+    // Since the public outputs are added into the public inputs list
+    // There can be duplicates. We keep the duplicates for when one is
+    // encoding the return values into the Verifier.toml
+    // However, for creating a proof, we remove these duplicates.
+    compiled_program.circuit.public_inputs =
+        dedup_public_input_indices(compiled_program.circuit.public_inputs);
+
     Ok((compiled_program, solved_witness))
 }
 

crates/nargo/src/cli/verify_cmd.rs

@@ -1,4 +1,6 @@
-use super::{compile_cmd::compile_circuit, read_inputs_from_file};
+use super::{
+    compile_cmd::compile_circuit, dedup_public_input_indices_values, read_inputs_from_file,
+};
 use crate::{
     constants::{PROOFS_DIR, PROOF_EXT, VERIFIER_INPUT_FILE},
     errors::CliError,
@@ -59,7 +61,7 @@ pub fn verify_with_path<P: AsRef<Path>>(
 }
 
 fn verify_proof(
-    compiled_program: CompiledProgram,
+    mut compiled_program: CompiledProgram,
     public_inputs: BTreeMap<String, InputValue>,
     proof: Vec<u8>,
 ) -> Result<bool, CliError> {
@@ -71,8 +73,14 @@ fn verify_proof(
         _ => CliError::from(error),
     })?;
 
+    // Similarly to when proving -- we must remove the duplicate public witnesses which
+    // can be present because a public input can also be added as a public output.
+    let (dedup_public_indices, dedup_public_values) =
+        dedup_public_input_indices_values(compiled_program.circuit.public_inputs, public_inputs);
+    compiled_program.circuit.public_inputs = dedup_public_indices;
+
     let backend = crate::backends::ConcreteBackend;
-    let valid_proof = backend.verify_from_cs(&proof, public_inputs, compiled_program.circuit);
+    let valid_proof = backend.verify_from_cs(&proof, dedup_public_values, compiled_program.circuit);
 
     Ok(valid_proof)
 }

crates/nargo/tests/test_data/hash_to_field/Prover.toml

@@ -1,2 +1 @@
 input = "1"
-return = "0x25cebc29ded2fa515a937e2b5f674e3026c012e5b57f8a48d7dce6b7d274f9d9"

crates/nargo/tests/test_data/higher-order-functions/Prover.toml

@@ -1 +1 @@
-return = "5"
+

crates/nargo/tests/test_data/main_return/Prover.toml

@@ -1,2 +1 @@
-return = ""
 x = "8"

crates/nargo/tests/test_data/main_return/src/main.nr

@@ -1,3 +1,3 @@
-fn main(x: Field) -> pub Field {
+fn main(x: pub Field) -> pub Field {
     x
 }