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, HashSet},
     fs::File,
     io::Write,
     path::{Path, PathBuf},
@@ -206,6 +207,37 @@ 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 = HashSet::new();
+
+    for (index, value) in indices.0.iter().zip(values) {
+        if !already_seen_public_indices.contains(&index) {
+            already_seen_public_indices.insert(index);
+            public_inputs_without_duplicates.push(value)
+        }
+    }
+
+    (
+        PublicInputs(already_seen_public_indices.into_iter().cloned().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,
@@ -46,9 +48,16 @@ pub fn prove_with_path<P: AsRef<Path>>(
     show_ssa: bool,
     allow_warnings: bool,
 ) -> Result<Option<PathBuf>, CliError> {
-    let (compiled_program, solved_witness) =
+    let (mut compiled_program, solved_witness) =
         compile_circuit_and_witness(program_dir, show_ssa, allow_warnings)?;
 
+    // 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);
+
     let backend = crate::backends::ConcreteBackend;
     let proof = backend.prove_with_meta(compiled_program.circuit, 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"