Forc deploy

forc/src/cli/commands/deploy.rs

@@ -1,8 +1,13 @@
 use structopt::{self, StructOpt};
 
+use crate::ops::forc_deploy;
+
 #[derive(Debug, StructOpt)]
-pub(crate) struct Command {}
+pub struct Command {}
 
 pub(crate) fn exec(command: Command) -> Result<(), String> {
-    todo!()
+    match forc_deploy::deploy(command) {
+        Err(e) => Err(e.message),
+        _ => Ok(()),
+    }
 }

forc/src/cli/mod.rs

@@ -10,7 +10,7 @@ use analysis::Command as AnalysisCommand;
 use benchmark::Command as BenchmarkCommand;
 pub use build::Command as BuildCommand;
 use coverage::Command as CoverageCommand;
-use deploy::Command as DeployCommand;
+pub use deploy::Command as DeployCommand;
 pub use format::Command as FormatCommand;
 use init::Command as InitCommand;
 use mvprun::Command as MvprunCommand;

forc/src/ops/forc_build.rs

@@ -1,4 +1,7 @@
-use crate::{cli::BuildCommand, utils::helpers::find_manifest_dir};
+use crate::{
+    cli::BuildCommand,
+    utils::helpers::{find_manifest_dir, get_main_file, read_manifest},
+};
 use line_col::LineColLookup;
 use source_span::{
     fmt::{Color, Formatter, Style},
@@ -8,12 +11,12 @@ use std::fs::File;
 use std::io::{self, Write};
 use termcolor::{BufferWriter, Color as TermColor, ColorChoice, ColorSpec, WriteColor};
 
-use crate::utils::manifest::{Dependency, DependencyDetails, Manifest};
+use crate::utils::manifest::{Dependency, DependencyDetails};
 use core_lang::{
     BuildConfig, BytecodeCompilationResult, CompilationResult, FinalizedAsm, LibraryExports,
     Namespace,
 };
-use std::{fs, path::PathBuf};
+use std::path::PathBuf;
 
 pub fn build(command: BuildCommand) -> Result<Vec<u8>, String> {
     let BuildCommand {
@@ -76,7 +79,7 @@ pub fn build(command: BuildCommand) -> Result<Vec<u8>, String> {
 
 /// Takes a dependency and returns a namespace of exported things from that dependency
 /// trait implementations are included as well
-fn compile_dependency_lib<'source, 'manifest>(
+pub fn compile_dependency_lib<'source, 'manifest>(
     project_path: &PathBuf,
     dependency_name: &'manifest str,
     dependency_lib: &Dependency,
@@ -138,28 +141,6 @@ fn compile_dependency_lib<'source, 'manifest>(
     Ok(())
 }
 
-fn read_manifest(manifest_dir: &PathBuf) -> Result<Manifest, String> {
-    let manifest_path = {
-        let mut man = manifest_dir.clone();
-        man.push(crate::utils::constants::MANIFEST_FILE_NAME);
-        man
-    };
-    let manifest_path_str = format!("{:?}", manifest_path);
-    let manifest = match std::fs::read_to_string(manifest_path) {
-        Ok(o) => o,
-        Err(e) => {
-            return Err(format!(
-                "failed to read manifest at {:?}: {}",
-                manifest_path_str, e
-            ))
-        }
-    };
-    match toml::from_str(&manifest) {
-        Ok(o) => Ok(o),
-        Err(e) => Err(format!("Error parsing manifest: {}.", e)),
-    }
-}
-
 fn compile_library<'source, 'manifest>(
     source: &'source str,
     proj_name: &str,
@@ -378,23 +359,6 @@ fn write_yellow(txt: &str) -> io::Result<()> {
     Ok(())
 }
 
-fn get_main_file(
-    manifest_of_dep: &Manifest,
-    manifest_dir: &PathBuf,
-) -> Result<&'static mut String, String> {
-    let main_path = {
-        let mut code_dir = manifest_dir.clone();
-        code_dir.push("src");
-        code_dir.push(&manifest_of_dep.project.entry);
-        code_dir
-    };
-
-    // some hackery to get around lifetimes for now, until the AST returns a non-lifetime-bound AST
-    let main_file = fs::read_to_string(&main_path).map_err(|e| e.to_string())?;
-    let main_file = Box::new(main_file);
-    let main_file: &'static mut String = Box::leak(main_file);
-    return Ok(main_file);
-}
 fn compile_to_asm<'source, 'manifest>(
     source: &'source str,
     proj_name: &str,

forc/src/ops/forc_deploy.rs

@@ -0,0 +1,135 @@
+use core_lang::{compile_to_bytecode, parse, BuildConfig, Namespace};
+use fuel_tx::{crypto::hash, ContractAddress, Output, Salt, Transaction};
+
+use crate::{
+    cli::DeployCommand,
+    utils::helpers::{find_manifest_dir, get_main_file, read_manifest},
+};
+use std::{fmt, io};
+
+use super::forc_build::compile_dependency_lib;
+
+pub fn deploy(_: DeployCommand) -> Result<(), DeployError> {
+    let curr_dir = std::env::current_dir()?;
+
+    match find_manifest_dir(&curr_dir) {
+        Some(manifest_dir) => {
+            let build_config = BuildConfig::root_from_manifest_path(manifest_dir.clone());
+            let manifest = read_manifest(&manifest_dir)?;
+            let mut namespace: Namespace = Default::default();
+
+            // compile dependencies
+            if let Some(ref deps) = manifest.dependencies {
+                for (dependency_name, dependency_details) in deps.iter() {
+                    compile_dependency_lib(
+                        &curr_dir,
+                        &dependency_name,
+                        &dependency_details,
+                        &mut namespace,
+                    )?;
+                }
+            }
+
+            // compile this program with all of its dependencies
+            let main_file = get_main_file(&manifest, &manifest_dir)?;
+
+            // parse it and check is it a contract
+            match parse(main_file) {
+                core_lang::CompileResult::Ok {
+                    value: parse_tree,
+                    warnings: _,
+                    errors: _,
+                } => {
+                    if let Some(_) = &parse_tree.contract_ast {
+                        // create Transaction::Create from contract file
+                        let compiled_contract =
+                            compile_contract(main_file, namespace, build_config)?;
+                        let tx = create_contract_tx(compiled_contract);
+                        println!("{:?}", tx);
+
+                        Ok(())
+                    } else {
+                        Err("Project is not a contract".into())
+                    }
+                }
+                _ => Err("Project does not compile".into()),
+            }
+        }
+        None => Err("Manifest file does not exist".into()),
+    }
+}
+
+fn compile_contract(
+    contract_file: &str,
+    namespace: Namespace,
+    build_config: BuildConfig,
+) -> Result<Vec<u8>, DeployError> {
+    let result = compile_to_bytecode(contract_file, &namespace, build_config);
+
+    match result {
+        core_lang::BytecodeCompilationResult::Success { bytes, warnings: _ } => Ok(bytes),
+        _ => Err("Failed to compile".into()),
+    }
+}
+
+fn create_contract_tx(compiled_contract: Vec<u8>) -> Transaction {
+    let gas_price = 0;
+    let gas_limit = 10000000;
+    let maturity = 0;
+    let bytecode_witness_index = 0;
+    let witnesses = vec![compiled_contract.into()];
+
+    let salt = Salt::new([0; 32]);
+    let static_contracts = vec![];
+    let inputs = vec![];
+
+    let zero_hash = hash("0".as_bytes());
+
+    let outputs = vec![Output::ContractCreated {
+        contract_id: ContractAddress::new(zero_hash.into()),
+    }];
+
+    Transaction::create(
+        gas_price,
+        gas_limit,
+        maturity,
+        bytecode_witness_index,
+        salt,
+        static_contracts,
+        inputs,
+        outputs,
+        witnesses,
+    )
+}
+
+pub struct DeployError {
+    pub message: String,
+}
+
+impl fmt::Display for DeployError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        write!(f, "{}", self)
+    }
+}
+
+impl From<&str> for DeployError {
+    fn from(s: &str) -> Self {
+        DeployError {
+            message: s.to_string(),
+        }
+    }
+}
+
+impl From<String> for DeployError {
+    fn from(s: String) -> Self {
+        DeployError { message: s }
+    }
+}
+
+impl From<io::Error> for DeployError {
+    fn from(e: io::Error) -> Self {
+        DeployError {
+            message: e.to_string(),
+        }
+    }
+}

forc/src/ops/mod.rs

@@ -1,3 +1,4 @@
 pub mod forc_build;
+pub mod forc_deploy;
 pub mod forc_fmt;
 pub mod forc_init;

forc/src/utils/helpers.rs

@@ -1,3 +1,4 @@
+use super::manifest::Manifest;
 use std::path::PathBuf;
 
 // Continually go up in the file tree until a manifest (Forc.toml) is found.
@@ -16,3 +17,43 @@ pub fn find_manifest_dir(starter_path: &PathBuf) -> Option<PathBuf> {
     }
     None
 }
+
+pub fn read_manifest(manifest_dir: &PathBuf) -> Result<Manifest, String> {
+    let manifest_path = {
+        let mut man = manifest_dir.clone();
+        man.push(crate::utils::constants::MANIFEST_FILE_NAME);
+        man
+    };
+    let manifest_path_str = format!("{:?}", manifest_path);
+    let manifest = match std::fs::read_to_string(manifest_path) {
+        Ok(o) => o,
+        Err(e) => {
+            return Err(format!(
+                "failed to read manifest at {:?}: {}",
+                manifest_path_str, e
+            ))
+        }
+    };
+    match toml::from_str(&manifest) {
+        Ok(o) => Ok(o),
+        Err(e) => Err(format!("Error parsing manifest: {}.", e)),
+    }
+}
+
+pub fn get_main_file(
+    manifest_of_dep: &Manifest,
+    manifest_dir: &PathBuf,
+) -> Result<&'static mut String, String> {
+    let main_path = {
+        let mut code_dir = manifest_dir.clone();
+        code_dir.push("src");
+        code_dir.push(&manifest_of_dep.project.entry);
+        code_dir
+    };
+
+    // some hackery to get around lifetimes for now, until the AST returns a non-lifetime-bound AST
+    let main_file = std::fs::read_to_string(&main_path).map_err(|e| e.to_string())?;
+    let main_file = Box::new(main_file);
+    let main_file: &'static mut String = Box::leak(main_file);
+    return Ok(main_file);
+}