Struct leo_compiler::compiler::Compiler

pub struct Compiler<F: Field + PrimeField, G: GroupType<F>> { /* fields omitted */ }

Implementations

impl<F: Field + PrimeField, G: GroupType<F>> Compiler<F, G>

pub fn new(
    package_name: String,
    main_file_path: PathBuf,
    output_directory: PathBuf
) -> Self

pub fn parse_input(
    &mut self,
    input_string: &str,
    state_string: &str
) -> Result<(), CompilerError>

Parse the input and state files. Stores a typed ast of all input variables to the program.

pub fn parse_program_without_input(
    package_name: String,
    main_file_path: PathBuf,
    output_directory: PathBuf
) -> Result<Self, CompilerError>

Parses program files. Returns a compiler struct that stores the typed program abstract syntax trees (ast).

pub fn parse_program_with_input(
    package_name: String,
    main_file_path: PathBuf,
    output_directory: PathBuf,
    input_string: &str,
    state_string: &str
) -> Result<Self, CompilerError>

Parses input, state, and program files. Returns a compiler struct that stores the typed input and typed program abstract syntax trees (ast).

pub fn parse_program_from_string(
    &mut self,
    program_string: &str
) -> Result<(), CompilerError>

👎 Deprecated:

Please use the 'parse_program' method instead.

Parses the Leo program string, constructs a syntax tree, and generates a program. Used for testing only.

pub fn set_main_input(&mut self, input: MainInput)

Manually sets main function input

pub fn verify_local_data_commitment(
    &self,
    system_parameters: &SystemParameters<Components>
) -> Result<bool, CompilerError>

Verifies the input to the program

pub fn checksum(&self) -> Result<String, CompilerError>

pub fn compile_constraints<CS: ConstraintSystem<F>>(
    self,
    cs: &mut CS
) -> Result<OutputBytes, CompilerError>

Synthesizes the circuit without program input to verify correctness.

pub fn compile_test_constraints(
    self,
    input_pairs: InputPairs
) -> Result<(), CompilerError>

Synthesizes the circuit for test functions with program input.

pub fn generate_constraints_helper<CS: ConstraintSystem<F>>(
    self,
    cs: &mut CS
) -> Result<OutputBytes, CompilerError>

Calls the internal generate_constraints method with arguments

pub fn to_bytes(&self) -> Result<Vec<u8>, CompilerError>

pub fn from_bytes(bytes: &[u8]) -> Result<Self, CompilerError>

Trait Implementations

impl<F: Clone + Field + PrimeField, G: Clone + GroupType<F>> Clone for Compiler<F, G>

fn clone(&self) -> Compiler<F, G>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Field + PrimeField, G: GroupType<F>> ConstraintSynthesizer<F> for Compiler<F, G>

fn generate_constraints<CS: ConstraintSystem<F>>(
    self,
    cs: &mut CS
) -> Result<(), SynthesisError>

Synthesizes the circuit with program input.