feat: artifact support

Cargo.toml

@@ -24,6 +24,9 @@ upon = { version = "0.9.0", default-features = false, features = [
 ] }
 colored = "3.0.0"
 
+[build-dependencies]
+cargo_toml = "0.22.3"
+
 [dev-dependencies]
 tempdir = "0.3.7"
 

build.rs

@@ -1,6 +1,34 @@
 use std::process::Command;
 
+use cargo_toml::Manifest;
+
 fn main() {
+    let toml_contents = std::fs::read("Cargo.toml").expect("Failed to find Cargo.toml");
+    let manifest =
+        Manifest::from_slice(&toml_contents).expect("Failed to parse Cargo.toml as Manifest");
+    let curl_version = {
+        let curl = manifest
+            .dependencies
+            .get("curl")
+            .expect("Couldn't find curl in parsed manifest");
+        match curl {
+            cargo_toml::Dependency::Simple(ver) => ver,
+            cargo_toml::Dependency::Detailed(detail) => &detail.version.as_ref().unwrap().clone(),
+            // This case should not happen since we are reading the root Cargo.toml
+            cargo_toml::Dependency::Inherited(_) => {
+                panic!("Couldn't determine curl version since it appears as inherited.")
+            },
+        }
+    };
+    // Pass the $CURL_VERSION to the crate at compile time.
+    println!("cargo:rustc-env=CURL_VERSION={}", curl_version);
+
+    // Pass the $TARGET to the crate at compile time.
+    println!(
+        "cargo:rustc-env=TARGET={}",
+        std::env::var("TARGET").expect("Failed to obtain $TARGET triple constant.")
+    );
+
     // Generated by cargo at runtime when the build script is run:
     // https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-build-scripts
     let build_script = std::env::var("OUT_DIR").unwrap();

manifest/channel-manifest.json

@@ -123,7 +123,13 @@
           "package": "miden-stdlib",
           "version": "0.17.2",
           "installed_library": "std.masp",
-          "library_struct": "miden_stdlib::StdLibrary"
+          "library_struct": "miden_stdlib::StdLibrary",
+          "artifacts": [
+              {
+                  "target": "zkvm-miden-unknown",
+                  "uri": "https://github.com/lima-limon-inc/fabriz.io/releases/download/0.0/std.masp"
+              }
+          ]
         },
         {
           "name": "base",
@@ -152,7 +158,13 @@
               "send": ["executable", "send"],
               "simulate": ["executable", "exec"]
           },
-          "initialization": ["init"]
+          "initialization": ["init"],
+          "artifacts": [
+              {
+                  "target": "aarch64-apple-darwin",
+                  "uri": "https://github.com/lima-limon-inc/fabriz.io/releases/download/0.0/fabrizio"
+              }
+          ]
         },
         {
           "name": "midenc",

src/artifact.rs

@@ -0,0 +1,157 @@
+use std::{fmt::Display, str::FromStr};
+
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Artifacts {
+    artifacts: Vec<Artifact>,
+}
+
+impl Artifacts {
+    /// Get a URI to download an artifact that's valid for [target].
+    pub fn get_uri_for(&self, target: &TargetTriple) -> Option<String> {
+        self.artifacts
+            .iter()
+            .find(|artifact| artifact.target == *target)
+            .map(|arti| arti.uri.clone())
+    }
+}
+
+/// Represents a mapping from a given [target] to the [url] which contains it.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+struct Artifact {
+    target: TargetTriple,
+
+    uri: String,
+}
+
+/// Struct that represents a target architecture by the rust compiler.
+/// There is no universal standadarized way to represent them, however,
+/// according to the
+/// [LLVM documentation](https://llvm.org/doxygen/Triple_8h_source.html),
+/// most triples have one of the following two shapes:
+/// - "ARCHITECTURE-VENDOR-OPERATING_SYSTEM"
+/// - "ARCHITECTURE-VENDOR-OPERATING_SYSTEM-ENVIRONMENT"
+///
+/// This template does match with two major wellknown targets:
+/// aarch64-apple-darwin and x86_64-unknown-linux-gnu.
+///
+/// There is one *notable* special case which is the Miden VM. MASP Libraries
+/// are OS/environent-agnostic, since they target the Miden VM itself. So, they
+/// use the following triplet: zkvm-miden-unknown
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct TargetTriple {
+    architecture: String,
+    vendor: String,
+    operating_system: String,
+    environment: Option<String>,
+}
+
+impl serde::ser::Serialize for TargetTriple {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+impl<'de> serde::de::Deserialize<'de> for TargetTriple {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        s.parse::<Self>().map_err(serde::de::Error::custom)
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum TargetTripleError {
+    #[error("Failed to deserialize TargetTriplet because: {0}")]
+    UnrecognizedTargetTriple(String),
+}
+
+impl FromStr for TargetTriple {
+    type Err = TargetTripleError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut parts = s.split("-");
+        let architecture = parts
+            .next()
+            .ok_or(TargetTripleError::UnrecognizedTargetTriple(
+                "Missing 'architecture' field".into(),
+            ))?
+            .into();
+        let vendor = parts
+            .next()
+            .ok_or(TargetTripleError::UnrecognizedTargetTriple("Missing 'vendor' field".into()))?
+            .into();
+        let operating_system = parts
+            .next()
+            .ok_or(TargetTripleError::UnrecognizedTargetTriple(
+                "Missing 'operating_system' field".into(),
+            ))?
+            .into();
+        let environment = parts.next().map(String::from);
+        Ok(TargetTriple {
+            architecture,
+            vendor,
+            operating_system,
+            environment,
+        })
+    }
+}
+
+impl Display for TargetTriple {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let repr = format!(
+            "{}-{}-{}{}",
+            self.architecture,
+            self.vendor,
+            self.operating_system,
+            self.environment.as_ref().map(|env| format!("-{}", env)).unwrap_or_default()
+        );
+        write!(f, "{repr}")
+    }
+}
+
+impl TargetTriple {
+    pub fn miden_vm() -> TargetTriple {
+        TargetTriple {
+            architecture: String::from("zkvm"),
+            vendor: String::from("miden"),
+            operating_system: String::from("unknown"),
+            environment: None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use super::TargetTriple;
+
+    #[test]
+    /// Test that we can parse triples that we actually support.
+    fn parse_wellknown_targets() {
+        let mut failed_parsing = Vec::new();
+        let well_known_targets =
+            ["aarch64-apple-darwin", "x86_64-unknown-linux-gnu", "zkvm-miden-unknown"];
+        for target in well_known_targets {
+            if let Err(err) = TargetTriple::from_str(target) {
+                failed_parsing.push((target, err));
+            }
+        }
+        if failed_parsing.is_empty() {
+            return;
+        }
+        let err_message = failed_parsing.iter().fold(
+            String::from("Failed to serialize the following well known targets:"),
+            |acc, (target, err)| format!("{acc}\n   - {target}, because {}", err),
+        );
+        panic!("{}", err_message)
+    }
+}

src/channel.rs

@@ -3,14 +3,16 @@ use std::{
     collections::{HashMap, HashSet},
     fmt::{self, Display},
     hash::{Hash, Hasher},
-    path::PathBuf,
+    path::{Path, PathBuf},
 };
 
 use anyhow::Context;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    Config, utils,
+    Config,
+    artifact::{Artifacts, TargetTriple},
+    utils,
     version::{Authority, GitTarget},
 };
 
@@ -269,6 +271,14 @@ impl InstalledFile {
             InstalledFile::Library { library_struct, .. } => Some(library_struct),
         }
     }
+    pub fn get_path_from(&self, toolchain_dir: &Path) -> PathBuf {
+        match &self {
+            exe @ InstalledFile::Executable { .. } => {
+                toolchain_dir.join("bin").join(exe.to_string())
+            },
+            lib @ InstalledFile::Library { .. } => toolchain_dir.join("lib").join(lib.to_string()),
+        }
+    }
 }
 
 impl Display for InstalledFile {
@@ -399,6 +409,9 @@ pub struct Component {
     #[serde(default)]
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub initialization: Vec<String>,
+    /// Pre-built artifact.
+    #[serde(flatten)]
+    artifacts: Option<Artifacts>,
 }
 
 impl Component {
@@ -413,6 +426,7 @@ impl Component {
             installed_file: None,
             initialization: vec![],
             aliases: HashMap::new(),
+            artifacts: None,
         }
     }
 
@@ -567,6 +581,11 @@ impl Component {
             self.call_format.clone()
         }
     }
+
+    /// Returns the URI for a given [target] (if available).
+    pub fn get_uri_for(&self, target: &TargetTriple) -> Option<String> {
+        self.artifacts.as_ref().and_then(|artifacts| artifacts.get_uri_for(target))
+    }
 }
 
 /// User-facing channel reference. The main difference with this and [Channel]
@@ -661,6 +680,7 @@ mod tests {
                 installed_file: None,
                 initialization: vec![],
                 aliases: HashMap::new(),
+                artifacts: None,
             },
             Component {
                 name: std::borrow::Cow::Borrowed("std"),
@@ -675,6 +695,7 @@ mod tests {
                 installed_file: None,
                 initialization: vec![],
                 aliases: HashMap::new(),
+                artifacts: None,
             },
             Component {
                 name: std::borrow::Cow::Borrowed("removed-component"),
@@ -689,6 +710,7 @@ mod tests {
                 installed_file: None,
                 initialization: vec![],
                 aliases: HashMap::new(),
+                artifacts: None,
             },
             Component {
                 name: std::borrow::Cow::Borrowed("base"),
@@ -703,6 +725,7 @@ mod tests {
                 installed_file: None,
                 initialization: vec![],
                 aliases: HashMap::new(),
+                artifacts: None,
             },
         ];
 
@@ -720,6 +743,7 @@ mod tests {
                 installed_file: None,
                 initialization: vec![],
                 aliases: HashMap::new(),
+                artifacts: None,
             },
             Component {
                 name: std::borrow::Cow::Borrowed("std"),
@@ -734,6 +758,7 @@ mod tests {
                 installed_file: None,
                 initialization: vec![],
                 aliases: HashMap::new(),
+                artifacts: None,
             },
             Component {
                 name: std::borrow::Cow::Borrowed("new-component"),
@@ -748,6 +773,7 @@ mod tests {
                 installed_file: None,
                 initialization: vec![],
                 aliases: HashMap::new(),
+                artifacts: None,
             },
             Component {
                 name: std::borrow::Cow::Borrowed("base"),
@@ -762,6 +788,7 @@ mod tests {
                 installed_file: None,
                 initialization: vec![],
                 aliases: HashMap::new(),
+                artifacts: None,
             },
         ];
 
@@ -808,6 +835,7 @@ mod tests {
             installed_file: None,
             initialization: vec![],
             aliases: HashMap::new(),
+            artifacts: None,
         }];
 
         let new_components = [Component {
@@ -823,6 +851,7 @@ mod tests {
             installed_file: None,
             initialization: vec![],
             aliases: HashMap::new(),
+            artifacts: None,
         }];
 
         let old = Channel {