jam_pvm_builder/

lib.rs

//! Builder logic for creating PVM code blobs for execution on the JAM PVM instances (service code
//! and authorizer code).

#![allow(clippy::unwrap_used)]

// If you update this, you should also update the toolchain installed by .github/workflows/rust.yml
const TOOLCHAIN: &str = "nightly-2025-05-10";

use codec::Encode;
use jam_program_blob_common::{ConventionalMetadata, CoreVmProgramBlob, CrateInfo, ProgramBlob};
use std::{
	fmt::Display,
	fs,
	path::{Path, PathBuf},
	process::Command,
	sync::OnceLock,
};

/// Program blob type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlobType {
	/// JAM service (`jam_pvm_common::Service`).
	Service,
	/// JAM authorizer (`jam_pvm_common::Authorizer`).
	Authorizer,
	/// CoreVM guest program (`corevm_guest` crate).
	CoreVmGuest,
}

impl Display for BlobType {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		std::fmt::Debug::fmt(self, f)
	}
}

impl BlobType {
	pub fn dispatch_table(&self) -> Vec<Vec<u8>> {
		match self {
			Self::Service => vec![b"refine_ext".into(), b"accumulate_ext".into()],
			Self::Authorizer => vec![b"is_authorized_ext".into()],
			Self::CoreVmGuest => Vec::new(),
		}
	}

	/// Get output file path for the specified crate name and output directory.
	pub fn output_file(&self, out_dir: &Path, crate_name: &str) -> PathBuf {
		let suffix = match self {
			Self::Service | Self::Authorizer => "jam",
			Self::CoreVmGuest => "corevm",
		};
		out_dir.join(format!("{crate_name}.{suffix}"))
	}
}

pub enum ProfileType {
	Debug,
	Release,
	Other(&'static str),
}
impl ProfileType {
	fn as_str(&self) -> &'static str {
		match self {
			ProfileType::Debug => "debug",
			ProfileType::Release => "release",
			ProfileType::Other(s) => s,
		}
	}
	fn to_arg(&self) -> String {
		match self {
			ProfileType::Debug => "--debug".into(),
			ProfileType::Release => "--release".into(),
			ProfileType::Other(s) => format!("--profile={s}"),
		}
	}
}

fn build_pvm_blob_in_build_script(crate_dir: &Path, blob_type: BlobType) {
	let out_dir: PathBuf = std::env::var("OUT_DIR").expect("No OUT_DIR").into();
	println!("cargo:rerun-if-env-changed=SKIP_PVM_BUILDS");
	println!("cargo:rerun-if-env-changed=PVM_BUILDER_STRIP");
	if std::env::var_os("SKIP_PVM_BUILDS").is_some() {
		let crate_name = get_crate_info(crate_dir).name;
		let output_file = blob_type.output_file(&out_dir, &crate_name);
		fs::write(&output_file, []).expect("error creating dummy program blob");
		println!("cargo:rustc-env=PVM_BINARY_{crate_name}={}", output_file.display());
	} else {
		println!("cargo:rerun-if-changed={}", crate_dir.to_str().unwrap());
		let (crate_name, output_file) =
			build_pvm_blob(crate_dir, blob_type, &out_dir, false, ProfileType::Other("production"));
		println!("cargo:rustc-env=PVM_BINARY_{crate_name}={}", output_file.display());
	}
}

/// Build the service crate in `crate_dir` for PVM.
///
/// Outputs
/// - `{out_dir}/{crate_name}.jam` - JAM program blob,
/// - `{out_dir}/{crate_name}.polkavm` - PolkaVM program blob for debugging.
///
/// The blob may be included in the relevant crate by using the [`pvm_binary`] macro.
pub fn build_service(crate_dir: &Path) {
	build_pvm_blob_in_build_script(crate_dir, BlobType::Service);
}

/// Build the authorizer crate in `crate_dir` for PVM.
///
/// Outputs
/// - `{out_dir}/{crate_name}.jam` - JAM program blob,
/// - `{out_dir}/{crate_name}.polkavm` - PolkaVM program blob for debugging.
///
/// The blob may be included in the relevant crate by using the [`pvm_binary`] macro.
pub fn build_authorizer(crate_dir: &Path) {
	build_pvm_blob_in_build_script(crate_dir, BlobType::Authorizer);
}

/// Build the CoreVM guest program crate in `crate_dir` for PVM.
///
/// Outputs
/// - `{out_dir}/{crate_name}.corevm` - CoreVM program blob,
/// - `{out_dir}/{crate_name}.polkavm` - PolkaVM program blob for debugging.
///
/// The blob may be included in the relevant crate by using the [`pvm_binary`] macro.
pub fn build_corevm_guest(crate_dir: &Path) {
	build_pvm_blob_in_build_script(crate_dir, BlobType::CoreVmGuest);
}

fn get_crate_info(crate_dir: &Path) -> CrateInfo {
	let read_manifest_output = Command::new("cargo")
		.current_dir(crate_dir)
		.arg("read-manifest")
		.output()
		.unwrap_or_else(|err| {
			panic!("Failed to run `cargo read-manifest` in {}: {err}", crate_dir.display());
		});
	if !read_manifest_output.status.success() {
		panic!(
			"Failed to read Cargo.toml manifest in {}:\n{}",
			crate_dir.display(),
			String::from_utf8_lossy(&read_manifest_output.stderr)
		);
	}
	let man = serde_json::from_slice::<serde_json::Value>(&read_manifest_output.stdout).unwrap();
	// read-manifest output should always contain a valid name/version
	let name = man.get("name").unwrap().as_str().unwrap().to_string();
	let version = man.get("version").unwrap().as_str().unwrap().to_string();
	// read-manifest output contains "license": null when no license is specified in the Cargo.toml
	let license = man
		.get("license")
		.unwrap()
		.as_str()
		.unwrap_or_else(|| {
			panic!("No license specified in Cargo.toml manifest in {}", crate_dir.display());
		})
		.to_string();
	// read-manifest output should always contain a valid authors list
	let authors = man
		.get("authors")
		.unwrap()
		.as_array()
		.unwrap()
		.iter()
		.map(|x| x.as_str().unwrap().to_owned())
		.collect::<Vec<String>>();
	CrateInfo { name, version, license, authors }
}

/// Build the PVM crate in `crate_dir` for the RISCV target.
///
/// Outputs
/// - depending on the `blob_type` either [JAM program blob](jam_program_blob_common::ProgramBlob)
///   or [CoreVM program blob](jam_program_blob_common::CoreVmProgramBlob) as
///   `{out_dir}/{crate_name}.jam` or `{out_dir}/{crate_name}.corevm` respectively;
/// - [PolkaVM program blob](polkavm_linker::ProgramBlob) as `{out_dir}/{crate_name}.polkavm` for
///   debugging.
///
/// `out_dir` is used to store any intermediate build files.
pub fn build_pvm_blob(
	crate_dir: &Path,
	blob_type: BlobType,
	out_dir: &Path,
	install_rustc: bool,
	profile: ProfileType,
) -> (String, PathBuf) {
	let (target_name, target_json_path) =
		("riscv64emac-unknown-none-polkavm", polkavm_linker::target_json_64_path().unwrap());

	println!("🪤 PVM module type: {blob_type}");
	println!("🎯 Target name: {target_name}");

	let rustup_installed = if Command::new("rustup").output().is_ok() {
		let output = Command::new("rustup")
			.args(["component", "list", "--toolchain", TOOLCHAIN, "--installed"])
			.output()
			.unwrap_or_else(|_| {
				panic!(
				"Failed to execute `rustup component list --toolchain {TOOLCHAIN} --installed`.\n\
		Please install `rustup` to continue.",
			)
			});

		if !output.status.success() ||
			!output.stdout.split(|x| *x == b'\n').any(|x| x[..] == b"rust-src"[..])
		{
			if install_rustc {
				println!("Installing rustc dependencies...");
				let mut child = Command::new("rustup")
					.args(["toolchain", "install", TOOLCHAIN, "-c", "rust-src"])
					.stdout(std::process::Stdio::inherit())
					.stderr(std::process::Stdio::inherit())
					.spawn()
					.unwrap_or_else(|_| {
						panic!(
						"Failed to execute `rustup toolchain install {TOOLCHAIN} -c rust-src`.\n\
				Please install `rustup` to continue."
					)
					});
				if !child.wait().expect("Failed to execute rustup process").success() {
					panic!("Failed to install `rust-src` component of {TOOLCHAIN}.");
				}
			} else {
				panic!("`rust-src` component of {TOOLCHAIN} is required to build the PVM binary.",);
			}
		}
		println!("ℹ️ `rustup` and toolchain installed. Continuing build process...");

		true
	} else {
		println!("ℹ️ `rustup` not installed, here be dragons. Continuing build process...");

		false
	};

	let info = get_crate_info(crate_dir);
	println!("📦 Crate name: {}", info.name);
	println!("🏷️ Build profile: {}", profile.as_str());

	let mut child = Command::new("cargo");

	child
		.current_dir(crate_dir)
		.env_clear()
		.env("PATH", std::env::var("PATH").unwrap())
		.env("RUSTFLAGS", "-C panic=abort")
		.env("CARGO_TARGET_DIR", out_dir)
		// Support building on stable. (required for `-Zbuild-std`)
		.env("RUSTC_BOOTSTRAP", "1");

	if rustup_installed {
		child.arg(format!("+{TOOLCHAIN}"));
	}

	child
		.args(["rustc", "--lib", "--crate-type=cdylib", "-Z", "build-std=core,alloc"])
		.arg(profile.to_arg())
		.arg("--target")
		.arg(target_json_path);

	// Use job server to not oversubscribe CPU cores when compiling multiple PVM binaries in
	// parallel.
	if let Some(client) = get_job_server_client() {
		client.configure(&mut child);
	}

	let mut child = child.spawn().expect("Failed to execute cargo process");
	let status = child.wait().expect("Failed to execute cargo process");

	if !status.success() {
		eprintln!("Failed to build RISC-V ELF due to cargo execution error");
		std::process::exit(1);
	}

	// Post processing
	println!("Converting RISC-V ELF to PVM blob...");
	let mut config = polkavm_linker::Config::default();
	config.set_strip(std::env::var("PVM_BUILDER_STRIP").map(|value| value == "1").unwrap_or(true));
	config.set_dispatch_table(blob_type.dispatch_table());

	let input_root = &out_dir.join(target_name).join(profile.as_str());
	let input_path_bin = input_root.join(&info.name);
	let input_path_cdylib = input_root.join(format!("{}.elf", info.name.replace("-", "_")));

	let input_path = if input_path_cdylib.exists() {
		if input_path_bin.exists() {
			eprintln!(
				"Both {} and {} exist; run 'cargo clean' to get rid of old artifacts!",
				input_path_cdylib.display(),
				input_path_bin.display()
			);
			std::process::exit(1);
		}
		input_path_cdylib
	} else if input_path_bin.exists() {
		input_path_bin
	} else {
		eprintln!(
			"Failed to build: neither {} nor {} exist",
			input_path_cdylib.display(),
			input_path_bin.display()
		);
		std::process::exit(1);
	};

	let orig =
		fs::read(&input_path).unwrap_or_else(|e| panic!("Failed to read {input_path:?} :{e:?}"));
	let linked = polkavm_linker::program_from_elf(config, orig.as_ref())
		.expect("Failed to link pvm program:");

	// Write out a full `.polkavm` blob for debugging/inspection.
	let output_path_pvm = &out_dir.join(format!("{}.polkavm", &info.name));
	fs::write(output_path_pvm, &linked).expect("Error writing resulting binary");
	let name = info.name.clone();
	let metadata = ConventionalMetadata::Info(info).encode().into();
	let output_file = blob_type.output_file(out_dir, &name);
	if !matches!(blob_type, BlobType::CoreVmGuest) {
		let parts = polkavm_linker::ProgramParts::from_bytes(linked.into())
			.expect("failed to deserialize linked PolkaVM program");
		let blob = ProgramBlob::from_pvm(&parts, metadata)
			.to_vec()
			.expect("error serializing the .jam blob");
		fs::write(&output_file, blob).expect("error writing the .jam blob");
	} else {
		let blob = CoreVmProgramBlob { metadata, pvm_blob: linked.into() }
			.to_vec()
			.expect("error serializing the CoreVM blob");
		fs::write(&output_file, blob).expect("error writing the CoreVM blob");
	}

	(name, output_file)
}

fn get_job_server_client() -> Option<&'static jobserver::Client> {
	static CLIENT: OnceLock<Option<jobserver::Client>> = OnceLock::new();
	CLIENT.get_or_init(|| unsafe { jobserver::Client::from_env() }).as_ref()
}

/// Returns the resulting blob as a byte slice.
#[macro_export]
macro_rules! pvm_binary {
	($name:literal) => {
		include_bytes!(env!(concat!("PVM_BINARY_", $name)))
	};
}