diff --git a/main/src/docker.rs b/main/src/docker.rs
index c7b430e..0b892f6 100644
--- a/main/src/docker.rs
+++ b/main/src/docker.rs
@@ -12,14 +12,11 @@ use crate::constants::TOOLCHAIN_FILE_NAME;
 use crate::macros::greyln;
 use crate::project::extract_toolchain_channel;
 
-fn version_to_image_name(version: &str) -> String {
-    format!("cargo-stylus-{}", version)
-}
-
-fn image_exists(name: &str) -> Result<bool> {
+fn image_exists() -> Result<bool> {
+    let image_name = format!("cargo-stylus-base:{}", env!("CARGO_PKG_VERSION"));
     let output = Command::new("docker")
         .arg("images")
-        .arg(name)
+        .arg(image_name)
         .output()
         .map_err(|e| eyre!("failed to execute Docker command: {e}"))?;
 
@@ -41,10 +38,11 @@ a reproducible deployment, or opt out by using the --no-verify flag for local bu
 }
 
 fn create_image(version: &str) -> Result<()> {
-    let name = version_to_image_name(version);
-    if image_exists(&name)? {
+    if image_exists()? {
         return Ok(());
     }
+    let pkg_version = env!("CARGO_PKG_VERSION");
+    let name = format!("cargo-stylus-base-{}-toolchain-{}", pkg_version, version);
     println!("Building Docker image for Rust toolchain {}", version,);
     let mut child = Command::new("docker")
         .arg("build")
@@ -58,12 +56,13 @@ fn create_image(version: &str) -> Result<()> {
     write!(
         child.stdin.as_mut().unwrap(),
         "\
-            FROM --platform=linux/amd64 offchainlabs/cargo-stylus-base:0.5.0 as base
+            FROM --platform=linux/amd64 offchainlabs/cargo-stylus-base:{} as base
             RUN rustup toolchain install {}-x86_64-unknown-linux-gnu 
             RUN rustup default {}-x86_64-unknown-linux-gnu
             RUN rustup target add wasm32-unknown-unknown
             RUN rustup component add rust-src --toolchain {}-x86_64-unknown-linux-gnu
         ",
+        pkg_version,
         version,
         version,
         version,
@@ -73,10 +72,8 @@ fn create_image(version: &str) -> Result<()> {
 }
 
 fn run_in_docker_container(version: &str, command_line: &[&str]) -> Result<()> {
-    let name = version_to_image_name(version);
-    if !image_exists(&name)? {
-        bail!("Docker image {name} doesn't exist");
-    }
+    let pkg_version = env!("CARGO_PKG_VERSION");
+    let name = format!("cargo-stylus-base-{}-toolchain-{}", pkg_version, version);
     let dir =
         std::env::current_dir().map_err(|e| eyre!("failed to find current directory: {e}"))?;
     Command::new("docker")
diff --git a/main/src/main.rs b/main/src/main.rs
index 9c4843c..ea2bd59 100644
--- a/main/src/main.rs
+++ b/main/src/main.rs
@@ -604,6 +604,7 @@ pub fn build_so(path: &Path) -> Result<()> {
         .current_dir(path)
         .arg("build")
         .arg("--lib")
+        .arg("--locked")
         .arg("--target")
         .arg(rustc_host::from_cli()?)
         .output()?;
diff --git a/main/src/project.rs b/main/src/project.rs
index 092692e..0f0fd4e 100644
--- a/main/src/project.rs
+++ b/main/src/project.rs
@@ -59,8 +59,14 @@ pub fn build_dylib(cfg: BuildConfig) -> Result<PathBuf> {
 
     let mut cmd = sys::new_command("cargo");
 
+    // Enforce a version is included in the Cargo.toml file.
+    let cargo_toml_path = cwd.join(Path::new("Cargo.toml"));
+    let cargo_toml_version = extract_cargo_toml_version(&cargo_toml_path)?;
+    greyln!("Building project with Cargo.toml version: {cargo_toml_version}");
+
     cmd.arg("build");
     cmd.arg("--lib");
+    cmd.arg("--locked");
 
     if !cfg.stable {
         cmd.arg("-Z");
@@ -203,6 +209,25 @@ pub fn extract_toolchain_channel(toolchain_file_path: &PathBuf) -> Result<String
     Ok(channel)
 }
 
+pub fn extract_cargo_toml_version(cargo_toml_path: &PathBuf) -> Result<String> {
+    let cargo_toml_contents = fs::read_to_string(cargo_toml_path)
+        .context("expected to find a Cargo.toml file in project directory")?;
+
+    let cargo_toml: Value =
+        toml::from_str(&cargo_toml_contents).context("failed to parse Cargo.toml")?;
+
+    let Some(pkg) = cargo_toml.get("package") else {
+        bail!("package section not found in Cargo.toml");
+    };
+    let Some(version) = pkg.get("version") else {
+        bail!("could not find version in project's Cargo.toml [package] section");
+    };
+    let Some(version) = version.as_str() else {
+        bail!("version in Cargo.toml's [package] section is not a string");
+    };
+    Ok(version.to_string())
+}
+
 pub fn hash_files(source_file_patterns: Vec<String>, cfg: BuildConfig) -> Result<[u8; 32]> {
     let mut keccak = Keccak::v256();
     let mut cmd = Command::new("cargo");