Merge pull request #374 from OffchainLabs/stylus-tools-project-hash

add project hash implementation to stylus-tools

Author: rory-ocl

Cargo.lock

@@ -36,6 +36,7 @@ brotli2 = "0.3.2"
 bytesize = "1.2.0"
 cargo_metadata = "0.20"
 escargot = "0.5"
+glob = "0.3"
 rust-toolchain-file = "0.1"
 rustc-host = "0.1"
 serde = { version = "1.0", features = ["derive"] }

stylus-tools/Cargo.toml

@@ -1,7 +1,7 @@
 // Copyright 2025, Offchain Labs, Inc.
 // For licensing, see https://github.com/OffchainLabs/stylus-sdk-rs/blob/main/licenses/COPYRIGHT.md
 
-use std::path::Path;
+use std::{env, path::Path};
 
 use alloy::{primitives::Address, providers::Provider};
 use bytesize::ByteSize;
@@ -28,6 +28,8 @@ pub struct CheckConfig {
 
 #[derive(Debug, thiserror::Error)]
 pub enum CheckError {
+    #[error("io error: {0}")]
+    Io(#[from] std::io::Error),
     #[error("cargo metadata error: {0}")]
     CargoMetadata(#[from] cargo_metadata::Error),
 
@@ -53,7 +55,8 @@ pub async fn check_contract(
     provider: &impl Provider,
 ) -> Result<ContractStatus, CheckError> {
     let wasm_file = build_contract(contract, &config.build)?;
-    let project_hash = hash_project(&config.project)?;
+    let dir = env::current_dir()?;
+    let project_hash = hash_project(dir, &config.project, &config.build)?;
     let status = check_wasm_file(&wasm_file, project_hash, address, config, provider).await?;
     Ok(status)
 }

stylus-tools/src/core/check.rs

@@ -1,20 +1,138 @@
 // Copyright 2025, Offchain Labs, Inc.
 // For licensing, see https://github.com/OffchainLabs/stylus-sdk-rs/blob/main/licenses/COPYRIGHT.md
 
-use tiny_keccak::{Hasher, Keccak};
+use std::{
+    fs,
+    io::Read,
+    path::{Path, PathBuf},
+    sync::mpsc,
+    thread,
+};
 
-use crate::utils::cargo;
+use glob::glob;
+use tiny_keccak::{Hasher, Keccak};
 
 use super::{ProjectConfig, ProjectError};
+use crate::{
+    core::build::{BuildConfig, OptLevel},
+    utils::{cargo, toolchain::find_toolchain_file},
+};
 
 pub type ProjectHash = [u8; 32];
 
-pub fn hash_project(_config: &ProjectConfig) -> Result<ProjectHash, ProjectError> {
+pub fn hash_project(
+    dir: impl AsRef<Path>,
+    config: &ProjectConfig,
+    build: &BuildConfig,
+) -> Result<ProjectHash, ProjectError> {
     let cargo_version = cargo::version()?;
 
     let mut keccak = Keccak::v256();
     keccak.update(cargo_version.as_bytes());
-    // TODO: hash project files
+    if matches!(build.opt_level, OptLevel::Z) {
+        keccak.update(&[0]);
+    } else {
+        keccak.update(&[1]);
+    }
+
+    // Fetch the Rust toolchain toml file from the project root. Assert that it exists and add it to the
+    // files in the directory to hash.
+    let toolchain_file_path = find_toolchain_file(dir.as_ref())?;
+
+    let mut paths = all_paths(dir, config.source_file_patterns.clone())?;
+    paths.push(toolchain_file_path);
+    paths.sort();
+
+    // Read the file contents in another thread and process the keccak in the main thread.
+    let (tx, rx) = mpsc::channel();
+    thread::spawn(move || {
+        for filename in paths.iter() {
+            greyln!(
+                "File used for deployment hash: {}",
+                filename.as_os_str().to_string_lossy()
+            );
+            tx.send(read_file_preimage(filename))
+                .expect("failed to send preimage (impossible)");
+        }
+    });
+    for result in rx {
+        keccak.update(result?.as_slice());
+    }
+
+    let mut project_hash = ProjectHash::default();
+    keccak.finalize(&mut project_hash);
+    greyln!(
+        "project metadata hash computed on deployment: {:?}",
+        hex::encode(project_hash)
+    );
+    Ok(project_hash)
+}
+
+fn all_paths(
+    root_dir: impl AsRef<Path>,
+    source_file_patterns: Vec<String>,
+) -> Result<Vec<PathBuf>, ProjectError> {
+    let mut files = Vec::<PathBuf>::new();
+    let mut directories = Vec::<PathBuf>::new();
+    directories.push(root_dir.as_ref().to_path_buf()); // Using `from` directly
+
+    let glob_paths = expand_glob_patterns(source_file_patterns)?;
+
+    while let Some(dir) = directories.pop() {
+        for entry in fs::read_dir(&dir).map_err(|e| ProjectError::DirectoryRead(dir.clone(), e))? {
+            let entry = entry.map_err(|e| ProjectError::DirectoryEntry(dir.clone(), e))?;
+            let path = entry.path();
+
+            if path.is_dir() {
+                if path.ends_with("target") || path.ends_with(".git") {
+                    continue; // Skip "target" and ".git" directories
+                }
+                directories.push(path);
+            } else if path.file_name().is_some_and(|f| {
+                // If the user has has specified a list of source file patterns, check if the file
+                // matches the pattern.
+                if !glob_paths.is_empty() {
+                    for glob_path in glob_paths.iter() {
+                        if glob_path == &path {
+                            return true;
+                        }
+                    }
+                    false
+                } else {
+                    // Otherwise, by default include all rust files, Cargo.toml and Cargo.lock files.
+                    f == "Cargo.toml" || f == "Cargo.lock" || f.to_string_lossy().ends_with(".rs")
+                }
+            }) {
+                files.push(path);
+            }
+        }
+    }
+    Ok(files)
+}
+
+fn expand_glob_patterns(patterns: Vec<String>) -> Result<Vec<PathBuf>, ProjectError> {
+    let mut files_to_include = Vec::new();
+    for pattern in patterns {
+        let paths = glob(&pattern).map_err(|e| ProjectError::GlobPattern(pattern.clone(), e))?;
+        for path_result in paths {
+            let path = path_result?;
+            files_to_include.push(path);
+        }
+    }
+    Ok(files_to_include)
+}
 
-    Ok(ProjectHash::default())
+fn read_file_preimage(filename: &Path) -> Result<Vec<u8>, ProjectError> {
+    let mut contents = Vec::with_capacity(1024);
+    {
+        let filename = filename.as_os_str();
+        contents.extend_from_slice(&(filename.len() as u64).to_be_bytes());
+        contents.extend_from_slice(filename.as_encoded_bytes());
+    }
+    let mut file = std::fs::File::open(filename)
+        .map_err(|e| ProjectError::FileOpen(filename.to_path_buf(), e))?;
+    contents.extend_from_slice(&file.metadata().unwrap().len().to_be_bytes());
+    file.read_to_end(&mut contents)
+        .map_err(|e| ProjectError::FileRead(filename.to_path_buf(), e))?;
+    Ok(contents)
 }

stylus-tools/src/core/project/hash.rs

@@ -1,6 +1,8 @@
 // Copyright 2025, Offchain Labs, Inc.
 // For licensing, see https://github.com/OffchainLabs/stylus-sdk-rs/blob/main/licenses/COPYRIGHT.md
 
+use std::path::PathBuf;
+
 pub use hash::{hash_project, ProjectHash};
 pub use init::{init_contract, init_workspace, InitError};
 pub use new::{new_contract, new_workspace};
@@ -25,6 +27,24 @@ pub enum ProjectKind {
 
 #[derive(Debug, thiserror::Error)]
 pub enum ProjectError {
+    #[error("io error: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("Error processing path: {0}")]
+    Glob(#[from] glob::GlobError),
+
     #[error("{0}")]
     Command(#[from] crate::error::CommandError),
+    #[error("rust toolchain error: {0}")]
+    Toolchain(#[from] crate::utils::toolchain::ToolchainError),
+
+    #[error("Unable to read directory {dir}: {1}", dir = .0.display())]
+    DirectoryRead(PathBuf, std::io::Error),
+    #[error("Error finding file in {dir}: {1}", dir = .0.display())]
+    DirectoryEntry(PathBuf, std::io::Error),
+    #[error("Failed to read glob pattern '{0}': {1}")]
+    GlobPattern(String, glob::PatternError),
+    #[error("failed to open file {filename}: {1}", filename = .0.display())]
+    FileOpen(PathBuf, std::io::Error),
+    #[error("failed to read file {filename}: {1}", filename = .0.display())]
+    FileRead(PathBuf, std::io::Error),
 }

stylus-tools/src/core/project/mod.rs

@@ -41,7 +41,7 @@ pub fn get_toolchain_channel(package: &Package) -> Result<String, ToolchainError
     Ok(channel)
 }
 
-fn find_toolchain_file(dir: impl Into<PathBuf>) -> Result<PathBuf, ToolchainError> {
+pub fn find_toolchain_file(dir: impl Into<PathBuf>) -> Result<PathBuf, ToolchainError> {
     let mut path = dir.into();
     while !path.join(TOOLCHAIN_FILE_NAME).exists() {
         path = path.parent().ok_or(ToolchainError::NotFound)?.to_path_buf();