leo/compiler/src/compiler.rs

260 lines
8.8 KiB
Rust
Raw Normal View History

2020-08-18 13:50:26 +03:00
// Copyright (C) 2019-2020 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
2020-05-06 04:40:25 +03:00
//! Compiles a Leo program from a file path.
use crate::{
2020-07-08 05:11:26 +03:00
constraints::{generate_constraints, generate_test_constraints},
2020-05-09 02:35:00 +03:00
errors::CompilerError,
2020-06-08 06:57:22 +03:00
GroupType,
2020-07-08 07:05:03 +03:00
ImportParser,
OutputBytes,
2020-08-01 07:15:33 +03:00
OutputFile,
};
use leo_ast::LeoAst;
2020-08-01 05:39:30 +03:00
use leo_input::LeoInputParser;
2020-08-16 08:09:22 +03:00
use leo_package::inputs::InputPairs;
use leo_state::verify_local_data_commitment;
2020-08-03 06:56:22 +03:00
use leo_typed::{Input, LeoTypedAst, MainInput, Program};
2020-04-25 11:47:10 +03:00
use snarkos_dpc::{base_dpc::instantiated::Components, SystemParameters};
2020-04-25 11:47:10 +03:00
use snarkos_errors::gadgets::SynthesisError;
use snarkos_models::{
curves::{Field, PrimeField},
2020-08-04 06:45:29 +03:00
gadgets::r1cs::{ConstraintSynthesizer, ConstraintSystem},
2020-04-25 11:47:10 +03:00
};
2020-05-04 21:40:29 +03:00
use sha2::{Digest, Sha256};
2020-04-28 00:36:05 +03:00
use std::{fs, marker::PhantomData, path::PathBuf};
2020-04-25 11:47:10 +03:00
#[derive(Clone)]
pub struct Compiler<F: Field + PrimeField, G: GroupType<F>> {
2020-05-02 08:10:40 +03:00
package_name: String,
2020-04-25 11:47:10 +03:00
main_file_path: PathBuf,
2020-08-01 07:15:33 +03:00
output_directory: PathBuf,
program: Program,
2020-08-01 05:39:30 +03:00
program_input: Input,
2020-07-08 07:05:03 +03:00
imported_programs: ImportParser,
2020-04-25 11:47:10 +03:00
_engine: PhantomData<F>,
_group: PhantomData<G>,
2020-04-25 11:47:10 +03:00
}
impl<F: Field + PrimeField, G: GroupType<F>> Compiler<F, G> {
2020-08-01 07:15:33 +03:00
pub fn new(package_name: String, main_file_path: PathBuf, output_directory: PathBuf) -> Self {
2020-06-09 03:28:09 +03:00
Self {
package_name: package_name.clone(),
main_file_path,
2020-08-01 07:15:33 +03:00
output_directory,
program: Program::new(package_name),
2020-08-01 05:39:30 +03:00
program_input: Input::new(),
2020-07-08 07:05:03 +03:00
imported_programs: ImportParser::new(),
2020-06-09 03:28:09 +03:00
_engine: PhantomData,
_group: PhantomData,
2020-06-09 03:28:09 +03:00
}
}
2020-08-03 03:24:31 +03:00
/// Parse the input and state files.
2020-08-03 04:51:44 +03:00
/// Stores a typed ast of all input variables to the program.
2020-09-03 08:59:54 +03:00
pub fn parse_input(
&mut self,
input_string: &str,
input_path: PathBuf,
state_string: &str,
) -> Result<(), CompilerError> {
let input_syntax_tree = LeoInputParser::parse_file(&input_string).map_err(|mut e| {
e.set_path(input_path.clone());
e
})?;
2020-08-03 04:51:44 +03:00
let state_syntax_tree = LeoInputParser::parse_file(&state_string)?;
2020-04-25 11:47:10 +03:00
2020-09-03 08:59:54 +03:00
self.program_input.parse_input(input_syntax_tree).map_err(|mut e| {
e.set_path(input_path);
e
})?;
2020-08-03 04:51:44 +03:00
self.program_input.parse_state(state_syntax_tree)?;
2020-08-03 03:24:31 +03:00
Ok(())
2020-06-11 02:14:55 +03:00
}
/// Parses program files.
/// Returns a compiler struct that stores the typed program abstract syntax trees (ast).
2020-08-01 05:39:30 +03:00
pub fn parse_program_without_input(
package_name: String,
main_file_path: PathBuf,
2020-08-01 07:15:33 +03:00
output_directory: PathBuf,
) -> Result<Self, CompilerError> {
2020-08-01 07:15:33 +03:00
let mut compiler = Self::new(package_name, main_file_path, output_directory);
2020-08-03 03:24:31 +03:00
compiler.parse_program()?;
Ok(compiler)
}
/// Parses input, state, and program files.
2020-08-01 05:39:30 +03:00
/// Returns a compiler struct that stores the typed input and typed program abstract syntax trees (ast).
pub fn parse_program_with_input(
2020-07-29 06:46:26 +03:00
package_name: String,
main_file_path: PathBuf,
2020-08-01 07:15:33 +03:00
output_directory: PathBuf,
2020-08-01 05:39:30 +03:00
input_string: &str,
2020-09-03 08:59:54 +03:00
input_path: PathBuf,
state_string: &str,
2020-07-29 06:46:26 +03:00
) -> Result<Self, CompilerError> {
2020-08-01 07:15:33 +03:00
let mut compiler = Self::new(package_name, main_file_path, output_directory);
2020-09-03 08:59:54 +03:00
compiler.parse_input(input_string, input_path, state_string)?;
2020-08-03 03:24:31 +03:00
compiler.parse_program()?;
2020-06-25 07:05:11 +03:00
Ok(compiler)
2020-04-25 11:47:10 +03:00
}
/// Parses the Leo program file, constructs a syntax tree, and generates a program.
2020-08-03 04:51:44 +03:00
pub(crate) fn parse_program(&mut self) -> Result<(), CompilerError> {
// Use the parser to construct the abstract syntax tree.
let program_string = LeoAst::load_file(&self.main_file_path)?;
2020-08-03 03:24:31 +03:00
self.parse_program_from_string(&program_string)
}
2020-07-29 08:26:28 +03:00
/// Parses the Leo program string, constructs a syntax tree, and generates a program.
/// Used for testing only.
2020-08-03 03:24:31 +03:00
#[deprecated(note = "Please use the 'parse_program' method instead.")]
pub fn parse_program_from_string(&mut self, program_string: &str) -> Result<(), CompilerError> {
// Use the given bytes to construct the abstract syntax tree.
let ast = LeoAst::new(&self.main_file_path, &program_string)?;
// Derive the package name.
let package_name = self.package_name.clone();
// Use the typed parser to construct the typed syntax tree.
let typed_tree = LeoTypedAst::new(&package_name, &ast);
self.program = typed_tree.into_repr();
self.imported_programs = ImportParser::parse(&self.program)?;
2020-08-22 02:36:50 +03:00
tracing::debug!("Program parsing complete\n{:#?}", self.program);
Ok(())
}
2020-08-01 05:39:30 +03:00
/// Manually sets main function input
pub fn set_main_input(&mut self, input: MainInput) {
self.program_input.set_main_input(input);
}
/// Verifies the input to the program
pub fn verify_local_data_commitment(
&self,
system_parameters: &SystemParameters<Components>,
) -> Result<bool, CompilerError> {
let result = verify_local_data_commitment(system_parameters, &self.program_input)?;
Ok(result)
}
pub fn checksum(&self) -> Result<String, CompilerError> {
// Read in the main file as string
2020-05-04 21:40:29 +03:00
let unparsed_file = fs::read_to_string(&self.main_file_path)
.map_err(|_| CompilerError::FileReadError(self.main_file_path.clone()))?;
// Hash the file contents
let mut hasher = Sha256::new();
2020-06-30 00:11:12 +03:00
hasher.update(unparsed_file.as_bytes());
let hash = hasher.finalize();
Ok(hex::encode(hash))
}
2020-08-01 05:39:30 +03:00
/// Synthesizes the circuit without program input to verify correctness.
pub fn compile_constraints<CS: ConstraintSystem<F>>(self, cs: &mut CS) -> Result<OutputBytes, CompilerError> {
2020-06-23 08:32:57 +03:00
let path = self.main_file_path;
2020-07-02 07:43:06 +03:00
generate_constraints::<F, G, CS>(cs, self.program, self.program_input, &self.imported_programs).map_err(
|mut error| {
error.set_path(path);
2020-06-23 08:32:57 +03:00
error
},
)
}
2020-08-01 05:39:30 +03:00
/// Synthesizes the circuit for test functions with program input.
2020-08-22 04:08:14 +03:00
pub fn compile_test_constraints(self, input_pairs: InputPairs) -> Result<(u32, u32), CompilerError> {
generate_test_constraints::<F, G>(
self.program,
input_pairs,
&self.imported_programs,
2020-08-22 04:08:14 +03:00
&self.main_file_path,
&self.output_directory,
)
2020-06-05 03:39:57 +03:00
}
/// Calls the internal generate_constraints method with arguments
pub fn generate_constraints_helper<CS: ConstraintSystem<F>>(
self,
cs: &mut CS,
) -> Result<OutputBytes, CompilerError> {
2020-07-31 03:19:10 +03:00
let path = self.main_file_path;
2020-08-01 05:39:30 +03:00
generate_constraints::<_, G, _>(cs, self.program, self.program_input, &self.imported_programs).map_err(
2020-07-31 03:19:10 +03:00
|mut error| {
error.set_path(path);
error
},
)
}
2020-06-25 07:05:11 +03:00
pub fn to_bytes(&self) -> Result<Vec<u8>, CompilerError> {
Ok(bincode::serialize(&self.program)?)
}
pub fn from_bytes(bytes: &[u8]) -> Result<Self, CompilerError> {
let program: Program = bincode::deserialize(bytes)?;
2020-08-01 05:39:30 +03:00
let program_input = Input::new();
2020-06-25 07:40:17 +03:00
2020-06-25 07:05:11 +03:00
Ok(Self {
package_name: program.name.clone(),
main_file_path: PathBuf::new(),
2020-08-01 07:15:33 +03:00
output_directory: PathBuf::new(),
2020-06-25 07:05:11 +03:00
program,
2020-08-01 05:39:30 +03:00
program_input,
2020-07-08 07:05:03 +03:00
imported_programs: ImportParser::new(),
2020-06-25 07:05:11 +03:00
_engine: PhantomData,
_group: PhantomData,
2020-06-25 07:05:11 +03:00
})
}
2020-05-02 08:10:40 +03:00
}
2020-04-25 11:47:10 +03:00
impl<F: Field + PrimeField, G: GroupType<F>> ConstraintSynthesizer<F> for Compiler<F, G> {
2020-08-01 05:39:30 +03:00
/// Synthesizes the circuit with program input.
2020-06-08 09:30:39 +03:00
fn generate_constraints<CS: ConstraintSystem<F>>(self, cs: &mut CS) -> Result<(), SynthesisError> {
2020-08-01 07:15:33 +03:00
let output_directory = self.output_directory.clone();
let package_name = self.package_name.clone();
let result = self.generate_constraints_helper(cs).map_err(|e| {
2020-08-22 02:36:50 +03:00
tracing::error!("{}", e);
SynthesisError::Unsatisfiable
})?;
2020-05-06 03:24:34 +03:00
// Write results to file
2020-08-01 07:15:33 +03:00
let output_file = OutputFile::new(&package_name);
output_file.write(&output_directory, result.bytes()).unwrap();
2020-05-06 03:24:34 +03:00
2020-04-25 11:47:10 +03:00
Ok(())
}
2020-04-28 00:36:05 +03:00
}