Struct Circuit

pub struct Circuit<F: AcirField> {
    pub function_name: String,
    pub current_witness_index: u32,
    pub opcodes: Vec<Opcode<F>>,
    pub private_parameters: BTreeSet<Witness>,
    pub public_parameters: PublicInputs,
    pub return_values: PublicInputs,
    pub assert_messages: Vec<(OpcodeLocation, AssertionPayload<F>)>,
}

Representation of a single ACIR circuit. The execution trace of this structure is dictated by the construction of a crate::native_types::WitnessMap

Fields

function_name: String

Name of the function represented by this circuit.

current_witness_index: u32

The current highest witness index in the circuit.

This is tracked as an optimization so that when new witness values are created, incrementing this witness results in a new unique witness index without needing to scan all opcodes to find the maximum witness index.

Note that if the current witness index is 0, it might mean that there were no witnesses created at all, or that there was exactly one witness.

opcodes: Vec<Opcode<F>>

The circuit opcodes representing the relationship between witness values.

The opcodes should be further converted into a backend-specific circuit representation. When initial witness inputs are provided, these opcodes can also be used for generating an execution trace.

private_parameters: BTreeSet<Witness>

The set of private inputs to the circuit.

public_parameters: PublicInputs

The set of public inputs provided by the prover.

return_values: PublicInputs

The set of public inputs calculated within the circuit.

assert_messages: Vec<(OpcodeLocation, AssertionPayload<F>)>

Maps opcode locations to failed assertion payloads. The data in the payload is embedded in the circuit to provide useful feedback to users when a constraint in the circuit is not satisfied.

Implementations

impl<F: AcirField> Circuit<F>

pub fn circuit_arguments(&self) -> BTreeSet<Witness>

Returns all witnesses which are required to execute the circuit successfully.

pub fn public_inputs(&self) -> PublicInputs

Returns all public inputs. This includes those provided as parameters to the circuit and those computed as return values.

impl Circuit<FieldElement>

pub fn from_str(src: &str) -> Result<Self, AcirParserErrorWithSource>

Creates a Circuit object from the given string.

pub fn from_str_impl(src: &str) -> Result<Self, AcirParserErrorWithSource>

Trait Implementations

impl<F: Clone + AcirField> Clone for Circuit<F>

fn clone(&self) -> Circuit<F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: AcirField> Debug for Circuit<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Default + AcirField> Default for Circuit<F>

fn default() -> Circuit<F>

Returns the “default value” for a type.

impl<'de, F> Deserialize<'de> for Circuit<F>

where F: Deserialize<'de> + AcirField,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F: AcirField> Display for Circuit<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for Circuit<FieldElement>

type Err = AcirParserErrorWithSource

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<F: Hash + AcirField> Hash for Circuit<F>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F: PartialEq + AcirField> PartialEq for Circuit<F>

fn eq(&self, other: &Circuit<F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F> Serialize for Circuit<F>

where F: Serialize + AcirField,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<F: Eq + AcirField> Eq for Circuit<F>

impl<F: AcirField> StructuralPartialEq for Circuit<F>