chore(refactor): Move resolved error structures out of acir crate

acvm-repo/acir/src/circuit/mod.rs

@@ -123,28 +123,6 @@ impl<'de> Deserialize<'de> for ErrorSelector {
     }
 }
 
-#[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
-pub struct RawAssertionPayload<F> {
-    pub selector: ErrorSelector,
-    pub data: Vec<F>,
-}
-
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub enum ResolvedAssertionPayload<F> {
-    String(String),
-    Raw(RawAssertionPayload<F>),
-}
-
-#[derive(Debug, Copy, Clone)]
-/// The opcode location for a call to a separate ACIR circuit
-/// This includes the function index of the caller within a [program][Program]
-/// and the index in the callers ACIR to the specific call opcode.
-/// This is only resolved and set during circuit execution.
-pub struct ResolvedOpcodeLocation {
-    pub acir_function_index: usize,
-    pub opcode_location: OpcodeLocation,
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
 #[cfg_attr(feature = "arb", derive(proptest_derive::Arbitrary))]
 /// Opcodes are locatable so that callers can

acvm-repo/acvm/src/pwg/brillig.rs

@@ -4,7 +4,7 @@ use acir::{
     AcirField,
     brillig::{ForeignCallParam, ForeignCallResult, Opcode as BrilligOpcode},
     circuit::{
-        ErrorSelector, OpcodeLocation, RawAssertionPayload, ResolvedAssertionPayload,
+        OpcodeLocation,
         brillig::{BrilligFunctionId, BrilligInputs, BrilligOutputs},
         opcodes::BlockId,
     },
@@ -16,7 +16,10 @@ use serde::{Deserialize, Serialize};
 
 use crate::{OpcodeResolutionError, pwg::OpcodeNotSolvable};
 
-use super::{get_value, insert_value, memory_op::MemoryOpSolver};
+use super::{
+    ErrorSelector, RawAssertionPayload, ResolvedAssertionPayload, get_value, insert_value,
+    memory_op::MemoryOpSolver,
+};
 
 #[derive(Debug)]
 pub enum BrilligSolverStatus<F> {

acvm-repo/acvm/src/pwg/mod.rs

@@ -7,7 +7,6 @@
     brillig::ForeignCallResult,
     circuit::{
         AssertionPayload, ErrorSelector, ExpressionOrMemory, Opcode, OpcodeLocation,
-        RawAssertionPayload, ResolvedAssertionPayload,
         brillig::{BrilligBytecode, BrilligFunctionId},
         opcodes::{
             AcirFunctionId, BlockId, ConstantOrWitnessEnum, FunctionInput, InvalidInputBitSize,
@@ -34,6 +33,7 @@
 
 pub use self::brillig::{BrilligSolver, BrilligSolverStatus};
 pub use brillig::ForeignCallWaitInfo;
+use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum ACVMStatus<F> {
@@ -55,7 +55,7 @@
     RequiresForeignCall(ForeignCallWaitInfo<F>),
 
     /// The ACVM has encountered a request for an ACIR [call][acir::circuit::Opcode]
     /// to execute a separate ACVM instance. The result of the ACIR call must be passd back to the ACVM.
     ///
     /// Once this is done, the ACVM can be restarted to solve the remaining opcodes.
     RequiresAcirCall(AcirCallWaitInfo<F>),
@@ -117,6 +117,18 @@
     }
 }
 
+#[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
+pub struct RawAssertionPayload<F> {
+    pub selector: ErrorSelector,
+    pub data: Vec<F>,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum ResolvedAssertionPayload<F> {
+    String(String),
+    Raw(RawAssertionPayload<F>),
+}
+
 #[derive(Clone, PartialEq, Eq, Debug, Error)]
 pub enum OpcodeResolutionError<F> {
     #[error("Cannot solve opcode: {0}")]

acvm-repo/acvm_js/src/execute.rs

@@ -1,12 +1,11 @@
 use std::{future::Future, pin::Pin};
 
-use acvm::acir::circuit::ResolvedAssertionPayload;
 use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::{BlackBoxFunctionSolver, FieldElement};
 use acvm::{
     acir::circuit::{Circuit, Program},
     acir::native_types::{WitnessMap, WitnessStack},
-    pwg::{ACVM, ACVMStatus, ErrorLocation, OpcodeResolutionError},
+    pwg::{ACVM, ACVMStatus, ErrorLocation, OpcodeResolutionError, ResolvedAssertionPayload},
 };
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 

acvm-repo/acvm_js/src/js_execution_error.rs

@@ -1,6 +1,7 @@
 use acvm::{
     FieldElement,
-    acir::circuit::{OpcodeLocation, RawAssertionPayload, brillig::BrilligFunctionId},
+    acir::circuit::{OpcodeLocation, brillig::BrilligFunctionId},
+    pwg::RawAssertionPayload,
 };
 use gloo_utils::format::JsValueSerdeExt;
 use js_sys::{Array, Error, JsString, Reflect};

tooling/nargo/src/errors.rs

@@ -2,11 +2,8 @@ use std::collections::BTreeMap;
 
 use acvm::{
     AcirField, FieldElement,
-    acir::circuit::{
-        ErrorSelector, OpcodeLocation, RawAssertionPayload, ResolvedAssertionPayload,
-        ResolvedOpcodeLocation, brillig::BrilligFunctionId,
-    },
-    pwg::{ErrorLocation, OpcodeResolutionError},
+    acir::circuit::{ErrorSelector, OpcodeLocation, brillig::BrilligFunctionId},
+    pwg::{ErrorLocation, OpcodeResolutionError, RawAssertionPayload, ResolvedAssertionPayload},
 };
 use noirc_abi::{Abi, AbiErrorType, display_abi_error};
 use noirc_errors::{CustomDiagnostic, debug_info::DebugInfo, reporter::ReportedErrors};
@@ -86,6 +83,16 @@ impl<F: AcirField> NargoError<F> {
     }
 }
 
+#[derive(Debug, Copy, Clone)]
+/// The opcode location for a call to a separate ACIR circuit
+/// This includes the function index of the caller within a [program][Program]
+/// and the index in the callers ACIR to the specific call opcode.
+/// This is only resolved and set during circuit execution.
+pub struct ResolvedOpcodeLocation {
+    pub acir_function_index: usize,
+    pub opcode_location: OpcodeLocation,
+}
+
 #[derive(Debug, Error)]
 pub enum ExecutionError<F: AcirField> {
     #[error("Failed assertion")]

tooling/nargo/src/ops/execute.rs

@@ -1,16 +1,15 @@
 use acvm::acir::circuit::brillig::BrilligBytecode;
-use acvm::acir::circuit::{
-    OpcodeLocation, Program, ResolvedAssertionPayload, ResolvedOpcodeLocation,
-};
+use acvm::acir::circuit::{OpcodeLocation, Program};
 use acvm::acir::native_types::WitnessStack;
 use acvm::pwg::{
     ACVM, ACVMStatus, ErrorLocation, OpcodeNotSolvable, OpcodeResolutionError, ProfilingSamples,
+    ResolvedAssertionPayload,
 };
 use acvm::{AcirField, BlackBoxFunctionSolver};
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
 
 use crate::NargoError;
-use crate::errors::ExecutionError;
+use crate::errors::{ExecutionError, ResolvedOpcodeLocation};
 use crate::foreign_calls::ForeignCallExecutor;
 
 struct ProgramExecutor<'a, F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>> {

tooling/noirc_abi_wasm/src/lib.rs

@@ -7,10 +7,8 @@
 
 use acvm::{
     FieldElement,
-    acir::{
-        circuit::RawAssertionPayload,
-        native_types::{WitnessMap, WitnessStack},
-    },
+    acir::native_types::{WitnessMap, WitnessStack},
+    pwg::RawAssertionPayload,
 };
 use iter_extended::try_btree_map;
 use noirc_abi::{
@@ -124,7 +122,7 @@
 }
 
 #[wasm_bindgen(js_name = serializeWitness)]
 pub fn serialise_witness(witness_map: JsWitnessMap) -> Result<Vec<u8>, JsAbiError> {
     console_error_panic_hook::set_once();
     let converted_witness: WitnessMap<FieldElement> = witness_map.into();
     let witness_stack: WitnessStack<FieldElement> = converted_witness.into();