feat(zkstack_cli): Add the ability to run the server from Docker without building it

zkstack_cli/Cargo.toml

@@ -53,6 +53,8 @@ lazy_static = "1.4.0"
 once_cell = "1.19.0"
 prost = "0.12.1"
 rand = "0.8.5"
+reqwest = { version = "0.12.8", features = ["json"] }
+semver = "1.0.23"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_yaml = "0.9"

zkstack_cli/crates/common/Cargo.toml

@@ -30,3 +30,5 @@ xshell.workspace = true
 thiserror.workspace = true
 strum.workspace = true
 git_version_macro.workspace = true
+reqwest.workspace = true
+semver.workspace = true

zkstack_cli/crates/common/src/github.rs

@@ -0,0 +1,112 @@
+use anyhow::{Context, Result};
+use reqwest::{
+    header::{HeaderMap, HeaderValue},
+    Client,
+};
+use semver::Version;
+use serde::{Deserialize, Serialize};
+
+const GITHUB_API_REPO_URL: &str = "https://api.github.com/repos/matter-labs/zksync-era";
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Tag {
+    pub name: String,
+    pub commit: Commit,
+    pub zipball_url: String,
+    pub tarball_url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Commit {
+    pub sha: String,
+    pub url: String,
+}
+
+/// Fetches and sorts GitHub repository tags by semantic version
+pub struct GitHubTagFetcher {
+    client: Client,
+    auth_token: Option<String>,
+}
+
+impl GitHubTagFetcher {
+    pub fn new(auth_token: Option<String>) -> Result<Self> {
+        let client = Client::new();
+        Ok(Self { client, auth_token })
+    }
+
+    pub async fn get_newest_core_tags(&self, limit: Option<usize>) -> Result<Vec<Tag>> {
+        let mut all_tags = Vec::new();
+        let mut page = 1;
+
+        // Set up headers
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            "Accept",
+            HeaderValue::from_static("application/vnd.github+json"),
+        );
+        headers.insert("User-Agent", HeaderValue::from_static("zkstack"));
+        headers.insert(
+            "X-GitHub-Api-Version",
+            HeaderValue::from_static("2022-11-28"),
+        );
+
+        if let Some(token) = &self.auth_token {
+            headers.insert(
+                "Authorization",
+                HeaderValue::from_str(&format!("Bearer {}", token))
+                    .context("Invalid authorization header")?,
+            );
+        }
+
+        // Fetch all pages
+        loop {
+            let url = format!("{}/tags?page={}&per_page=100", GITHUB_API_REPO_URL, page);
+
+            let response = self
+                .client
+                .get(&url)
+                .headers(headers.clone())
+                .send()
+                .await?;
+
+            if !response.status().is_success() {
+                return Err(anyhow::anyhow!(
+                    "GitHub API request failed with status: {}",
+                    response.status()
+                ));
+            }
+
+            let page_tags: Vec<Tag> = response.json().await?;
+            if page_tags.is_empty() {
+                break;
+            }
+
+            all_tags.extend(page_tags);
+            page += 1;
+        }
+
+        // filter tag names containing "core"
+        all_tags.retain(|t| t.name.contains("core"));
+
+        // Sort tags by semantic version
+        all_tags.sort_by(|a, b| {
+            let version_a = clean_version(&a.name);
+            let version_b = clean_version(&b.name);
+            version_b.cmp(&version_a) // Reverse order (newest first)
+        });
+
+        // Apply limit if specified
+        Ok(if let Some(limit) = limit {
+            all_tags.into_iter().take(limit).collect()
+        } else {
+            all_tags
+        })
+    }
+}
+
+/// Cleans and parses version strings into semver::Version
+fn clean_version(tag_name: &str) -> Version {
+    // Remove "core-v" prefix and parse the version string
+    let cleaned = tag_name.trim_start_matches("core-v");
+    Version::parse(cleaned).unwrap_or_else(|_| Version::new(0, 0, 0))
+}

zkstack_cli/crates/common/src/lib.rs

@@ -12,6 +12,7 @@ pub mod external_node;
 pub mod files;
 pub mod forge;
 pub mod git;
+pub mod github;
 pub mod server;
 pub mod version;
 pub mod wallets;

zkstack_cli/crates/common/src/server.rs

@@ -1,5 +1,6 @@
 use std::{ffi::OsStr, path::PathBuf};
 
+use anyhow::Context;
 use xshell::{cmd, Shell};
 
 use crate::cmd::Cmd;
@@ -19,6 +20,17 @@ pub enum ServerMode {
     Genesis,
 }
 
+/// Possible execution modes.
+#[derive(Clone, Debug, Default)]
+pub enum ExecutionMode {
+    #[default]
+    Release,
+    Debug,
+    Docker {
+        tag: String,
+    },
+}
+
 impl Server {
     /// Creates a new instance of the server.
     pub fn new(components: Option<Vec<String>>, code_path: PathBuf, uring: bool) -> Self {
@@ -31,16 +43,18 @@ impl Server {
 
     /// Runs the server.
     #[allow(clippy::too_many_arguments)]
-    pub fn run<P>(
+    pub async fn run<P>(
         &self,
         shell: &Shell,
+        execution_mode: ExecutionMode,
         server_mode: ServerMode,
         genesis_path: P,
         wallets_path: P,
         general_path: P,
         secrets_path: P,
         contracts_path: P,
         mut additional_args: Vec<String>,
+        ports: Vec<u16>,
     ) -> anyhow::Result<()>
     where
         P: AsRef<OsStr>,
@@ -56,28 +70,20 @@ impl Server {
 
         let uring = self.uring.then_some("--features=rocksdb/io-uring");
 
-        let mut cmd = Cmd::new(
-            cmd!(
-                shell,
-                "cargo run --release --bin zksync_server {uring...} --
-                --genesis-path {genesis_path}
-                --wallets-path {wallets_path}
-                --config-path {general_path}
-                --secrets-path {secrets_path}
-                --contracts-config-path {contracts_path}
-                "
-            )
-            .args(additional_args)
-            .env_remove("RUSTUP_TOOLCHAIN"),
-        );
-
-        // If we are running server in normal mode
-        // we need to get the output to the console
-        if let ServerMode::Normal = server_mode {
-            cmd = cmd.with_force_run();
-        }
-
-        cmd.run()?;
+        run_server(
+            shell,
+            uring,
+            genesis_path,
+            wallets_path,
+            general_path,
+            secrets_path,
+            contracts_path,
+            additional_args,
+            execution_mode,
+            server_mode,
+            ports,
+        )
+        .await?;
 
         Ok(())
     }
@@ -99,3 +105,160 @@ impl Server {
         })
     }
 }
+
+#[allow(clippy::too_many_arguments)]
+async fn run_server<P>(
+    shell: &Shell,
+    uring: Option<&str>,
+    genesis_path: P,
+    wallets_path: P,
+    general_path: P,
+    secrets_path: P,
+    contracts_path: P,
+    additional_args: Vec<String>,
+    execution_mode: ExecutionMode,
+    server_mode: ServerMode,
+    ports: Vec<u16>,
+) -> anyhow::Result<()>
+where
+    P: AsRef<OsStr>,
+{
+    let mut cmd = match execution_mode {
+        ExecutionMode::Release => cargo_run(
+            shell,
+            true,
+            uring,
+            genesis_path,
+            wallets_path,
+            general_path,
+            secrets_path,
+            contracts_path,
+            additional_args,
+        ),
+        ExecutionMode::Debug => cargo_run(
+            shell,
+            false,
+            uring,
+            genesis_path,
+            wallets_path,
+            general_path,
+            secrets_path,
+            contracts_path,
+            additional_args,
+        ),
+        ExecutionMode::Docker { tag } => docker_run(
+            shell,
+            genesis_path,
+            wallets_path,
+            general_path,
+            secrets_path,
+            contracts_path,
+            additional_args,
+            tag,
+            ports,
+        ),
+    };
+
+    // If we are running server in normal mode
+    // we need to get the output to the console
+    if let ServerMode::Normal = server_mode {
+        cmd = cmd.with_force_run();
+    }
+
+    cmd.run().context("Failed to run server")
+}
+
+#[allow(clippy::too_many_arguments)]
+fn cargo_run<'a, P>(
+    shell: &'a Shell,
+    release: bool,
+    uring: Option<&str>,
+    genesis_path: P,
+    wallets_path: P,
+    general_path: P,
+    secrets_path: P,
+    contracts_path: P,
+    additional_args: Vec<String>,
+) -> Cmd<'a>
+where
+    P: AsRef<OsStr>,
+{
+    let compilation_mode: &str = if release { "--release" } else { "" };
+
+    Cmd::new(
+        cmd!(
+            shell,
+            "cargo run {compilation_mode} --bin zksync_server {uring...} --
+            --genesis-path {genesis_path}
+            --wallets-path {wallets_path}
+            --config-path {general_path}
+            --secrets-path {secrets_path}
+            --contracts-config-path {contracts_path}
+            "
+        )
+        .args(additional_args)
+        .env_remove("RUSTUP_TOOLCHAIN"),
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn docker_run<P>(
+    shell: &Shell,
+    genesis_path: P,
+    wallets_path: P,
+    general_path: P,
+    secrets_path: P,
+    contracts_path: P,
+    additional_args: Vec<String>,
+    tag: String,
+    ports: Vec<u16>,
+) -> Cmd<'_>
+where
+    P: AsRef<OsStr>,
+{
+    let genesis_path = genesis_path.as_ref().to_string_lossy();
+    let wallets_path = wallets_path.as_ref().to_string_lossy();
+    let general_path = general_path.as_ref().to_string_lossy();
+    let secrets_path = secrets_path.as_ref().to_string_lossy();
+    let contracts_path = contracts_path.as_ref().to_string_lossy();
+
+    // do not expose postgres and reth ports
+    let ports = ports
+        .into_iter()
+        .filter(|p| *p != 5432 && *p != 8545)
+        .collect::<Vec<_>>();
+
+    let mut cmd = cmd!(shell, "docker run")
+        .arg("--platform")
+        .arg("linux/amd64")
+        .arg("-v")
+        .arg(format!("{genesis_path}:/config/genesis.yaml"))
+        .arg("-v")
+        .arg(format!("{wallets_path}:/config/wallets.yaml"))
+        .arg("-v")
+        .arg(format!("{general_path}:/config/general.yaml"))
+        .arg("-v")
+        .arg(format!("{secrets_path}:/config/secrets.yaml"))
+        .arg("-v")
+        .arg(format!("{contracts_path}:/config/contracts.yaml"));
+
+    for p in ports {
+        cmd = cmd.arg("-p").arg(format!("{p}:{p}"));
+    }
+
+    cmd = cmd
+        .arg(format!("matterlabs/server-v2:{tag}"))
+        .arg("--genesis-path")
+        .arg("/config/genesis.yaml")
+        .arg("--wallets-path")
+        .arg("/config/wallets.yaml")
+        .arg("--config-path")
+        .arg("/config/general.yaml")
+        .arg("--secrets-path")
+        .arg("/config/secrets.yaml")
+        .arg("--contracts-config-path")
+        .arg("/config/contracts.yaml")
+        .args(additional_args);
+
+    Cmd::new(cmd)
+}