diff --git a/FULL_HELP_DOCS.md b/FULL_HELP_DOCS.md
index 109e02ebae..05d09ee8e2 100644
--- a/FULL_HELP_DOCS.md
+++ b/FULL_HELP_DOCS.md
@@ -422,6 +422,19 @@ To view the commands that will be executed, without executing them, use the --pr
 
 - `--print-commands-only` — Print commands to build without executing them
 
+  Incompatible with `--verifiable`, which compiles from a throwaway extracted-archive tempdir that only exists for the build, so a printed command bind-mounting it could never be replayed.
+
+###### **Verifiable Options:**
+
+- `--verifiable` — Produce a SEP-58 verifiable (reproducible) build.
+
+  Snapshots the working tree into a byte-reproducible source archive, builds it in a digest-pinned container image, and records provenance meta (bldimg, source_uri, source_sha256, bldopt) into the wasm so a third party can reproduce the exact bytes. Implies `--locked`. Requires a clean git tree. Requires `--image` pinned by digest (`<registry-host>/<repo>@sha256:<64-hex>`) so the recorded `bldimg` names the exact bytes.
+
+  Incompatible with `--print-commands-only`: a verifiable build compiles from an extracted-archive tempdir that only exists for the build, so a printed command bind-mounting it could never be replayed.
+
+- `--source-sha256 <SOURCE_SHA256>` — Pin the SEP-58 source_sha256 of the generated archive (64-char lower-case hex). The build fails if the archive hashes to a different value
+- `--source-uri <SOURCE_URI>` — Record a SEP-58 source_uri where the source archive can be fetched (a URI with a scheme, e.g. https://example.com/src.tar.gz)
+
 ## `stellar contract archive`
 
 Generate the reproducible source archive used by verifiable builds
diff --git a/cmd/crates/soroban-test/tests/it/build.rs b/cmd/crates/soroban-test/tests/it/build.rs
index b5c002a8b0..060ed8cf02 100644
--- a/cmd/crates/soroban-test/tests/it/build.rs
+++ b/cmd/crates/soroban-test/tests/it/build.rs
@@ -1081,6 +1081,9 @@ fn build_always_injects_cli_version() {
     );
 }
 
+const ZERO_DIGEST: &str =
+    "docker.io/stellar/stellar-cli@sha256:0000000000000000000000000000000000000000000000000000000000000000";
+
 // Convenience: drive a git command in a fixture directory.
 fn git_in(dir: &Path, args: &[&str]) {
     std::process::Command::new("git")
@@ -1104,6 +1107,146 @@ fn fresh_workspace() -> (TempDir, PathBuf) {
     (temp, workspace)
 }
 
+// `--verifiable` cannot accept reserved `--meta` keys that the cli writes itself.
+#[test]
+fn verifiable_meta_conflict_errors() {
+    let sandbox = TestEnv::default();
+    let cargo_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let fixture_path = cargo_dir.join("tests/fixtures/workspace/contracts/add");
+
+    sandbox
+        .new_assert_cmd("contract")
+        .current_dir(fixture_path)
+        .arg("build")
+        .arg("--verifiable")
+        .arg("--image")
+        .arg(ZERO_DIGEST)
+        .arg("--source-sha256")
+        .arg("a".repeat(64))
+        .arg("--meta")
+        .arg("bldimg=not-allowed")
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("reserved key: bldimg"));
+}
+
+// A verifiable build compiles from a throwaway extracted-archive tempdir, so a
+// `--print-commands-only` command bind-mounting it could never be replayed;
+// clap rejects the combination up front.
+#[test]
+fn verifiable_rejects_print_commands_only() {
+    let sandbox = TestEnv::default();
+    let cargo_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let fixture_path = cargo_dir.join("tests/fixtures/workspace/contracts/add");
+
+    sandbox
+        .new_assert_cmd("contract")
+        .current_dir(fixture_path)
+        .arg("build")
+        .arg("--verifiable")
+        .arg("--image")
+        .arg(ZERO_DIGEST)
+        .arg("--print-commands-only")
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("cannot be used with"));
+}
+
+// `--image` is validated against the SEP-58 bldimg regex; tag-only refs fail.
+#[test]
+fn verifiable_image_must_be_digest_pinned() {
+    let sandbox = TestEnv::default();
+    let cargo_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let fixture_path = cargo_dir.join("tests/fixtures/workspace/contracts/add");
+
+    sandbox
+        .new_assert_cmd("contract")
+        .current_dir(fixture_path)
+        .arg("build")
+        .arg("--verifiable")
+        .arg("--image")
+        .arg("docker.io/stellar/stellar-cli:latest")
+        .arg("--source-sha256")
+        .arg("a".repeat(64))
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("bldimg format"));
+}
+
+// SEP-58 metadata must be ASCII; a non-ASCII `--image` is rejected before the
+// bldimg format check.
+#[test]
+fn verifiable_image_must_be_ascii() {
+    let sandbox = TestEnv::default();
+    let cargo_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let fixture_path = cargo_dir.join("tests/fixtures/workspace/contracts/add");
+
+    let non_ascii = format!("localhost:5000/café@sha256:{}", "0".repeat(64));
+
+    sandbox
+        .new_assert_cmd("contract")
+        .current_dir(fixture_path)
+        .arg("build")
+        .arg("--verifiable")
+        .arg("--image")
+        .arg(non_ascii)
+        .arg("--source-sha256")
+        .arg("a".repeat(64))
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("must be ASCII"));
+}
+
+// SEP-58 bldimg requires an explicit registry host (e.g. `docker.io/...`).
+// Implicit Docker-Hub-style short refs are rejected.
+#[test]
+fn verifiable_image_requires_explicit_registry_host() {
+    let sandbox = TestEnv::default();
+    let cargo_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let fixture_path = cargo_dir.join("tests/fixtures/workspace/contracts/add");
+
+    let short_ref = format!("stellar/stellar-cli@sha256:{}", "0".repeat(64));
+
+    sandbox
+        .new_assert_cmd("contract")
+        .current_dir(fixture_path)
+        .arg("build")
+        .arg("--verifiable")
+        .arg("--image")
+        .arg(short_ref)
+        .arg("--source-sha256")
+        .arg("a".repeat(64))
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("bldimg format"));
+}
+
+// `--verifiable` always generates the source archive (and computes
+// source_sha256) before the docker stage, so the "Wrote source archive" line
+// appears even though the build then fails to reach a real image.
+#[test]
+fn verifiable_always_writes_source_archive() {
+    let sandbox = TestEnv::default();
+    let (_temp, workspace) = fresh_workspace();
+    git_in(&workspace, &["init", "-q", "-b", "main"]);
+    git_in(&workspace, &["add", "-A"]);
+    git_in(&workspace, &["commit", "-q", "-m", "init"]);
+
+    sandbox
+        .new_assert_cmd("contract")
+        .current_dir(workspace.join("contracts").join("add"))
+        .arg("build")
+        .arg("--verifiable")
+        .arg("--image")
+        .arg(ZERO_DIGEST)
+        .assert()
+        .failure()
+        .stderr(
+            predicate::str::contains("Wrote source archive")
+                .and(predicate::str::contains("source_sha256")),
+        );
+}
+
 // `contract archive --out-file` writes the gzipped tarball and prints its
 // source_sha256.
 #[test]
@@ -1285,3 +1428,73 @@ fn contract_archive_dirty_tree_errors() {
         "no archive should be written for a dirty tree"
     );
 }
+
+// `--source-sha256` value must match the 64-hex regex.
+#[test]
+fn verifiable_source_sha256_format_errors() {
+    let sandbox = TestEnv::default();
+    let cargo_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let fixture_path = cargo_dir.join("tests/fixtures/workspace/contracts/add");
+
+    sandbox
+        .new_assert_cmd("contract")
+        .current_dir(fixture_path)
+        .arg("build")
+        .arg("--verifiable")
+        .arg("--image")
+        .arg(ZERO_DIGEST)
+        .arg("--source-sha256")
+        .arg("not-a-sha")
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("source_sha256 format"));
+}
+
+// `--source-uri` value must be a URI with a scheme.
+#[test]
+fn verifiable_source_uri_format_errors() {
+    let sandbox = TestEnv::default();
+    let cargo_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let fixture_path = cargo_dir.join("tests/fixtures/workspace/contracts/add");
+
+    sandbox
+        .new_assert_cmd("contract")
+        .current_dir(fixture_path)
+        .arg("build")
+        .arg("--verifiable")
+        .arg("--image")
+        .arg(ZERO_DIGEST)
+        .arg("--source-sha256")
+        .arg("a".repeat(64))
+        .arg("--source-uri")
+        .arg("not a uri")
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("source_uri format"));
+}
+
+// A dirty git tree is a hard fail under `--verifiable` (the recorded
+// source_sha256 would not describe the bytes built).
+#[test]
+fn verifiable_dirty_tree_errors() {
+    let sandbox = TestEnv::default();
+    let (_temp, workspace) = fresh_workspace();
+    git_in(&workspace, &["init", "-q", "-b", "main"]);
+    git_in(&workspace, &["add", "-A"]);
+    git_in(&workspace, &["commit", "-q", "-m", "init"]);
+    // Dirty the tree after committing so status is non-empty.
+    std::fs::write(workspace.join("dirty.txt"), b"uncommitted").unwrap();
+
+    sandbox
+        .new_assert_cmd("contract")
+        .current_dir(workspace.join("contracts").join("add"))
+        .arg("build")
+        .arg("--verifiable")
+        .arg("--image")
+        .arg(ZERO_DIGEST)
+        .arg("--source-sha256")
+        .arg("a".repeat(64))
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("dirty").or(predicate::str::contains("clean tree")));
+}
diff --git a/cmd/soroban-cli/src/commands/container/shared.rs b/cmd/soroban-cli/src/commands/container/shared.rs
index 3bbd073918..4b67b7764a 100644
--- a/cmd/soroban-cli/src/commands/container/shared.rs
+++ b/cmd/soroban-cli/src/commands/container/shared.rs
@@ -1,6 +1,8 @@
 use core::fmt;
+use std::process::Stdio;
 
 use clap::ValueEnum;
+use tokio::io::{AsyncBufReadExt, AsyncReadExt, BufReader};
 use tokio::process::Command;
 
 use crate::print::Print;
@@ -20,6 +22,9 @@ pub enum Error {
         program: String,
         source: std::io::Error,
     },
+
+    #[error("could not pull image {image}: {stderr}")]
+    PullImageFailed { image: String, stderr: String },
 }
 
 /// Container runtime to shell out to.
@@ -261,6 +266,59 @@ impl Args {
         };
         cmd
     }
+
+    /// Pull `image`, streaming the engine's high-level status lines ("Pulling
+    /// from", "Digest", "Status") through `print`. Per-layer progress written to
+    /// stderr is captured rather than shown and surfaced only when the pull
+    /// fails, as `PullImageFailed` — callers that need to explain a failed pull
+    /// (e.g. the verifiable build's tag-listing hint) rely on that captured text.
+    /// A missing engine binary surfaces via `io_error` as `NotFound`.
+    pub(crate) async fn pull_image(&self, image: &str, print: &Print) -> Result<(), Error> {
+        let mut child = self
+            .pull_command(image)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+            .map_err(|e| self.io_error(e))?;
+
+        let stdout = child.stdout.take();
+        let stderr = child.stderr.take();
+
+        let stream_stdout = async {
+            if let Some(stdout) = stdout {
+                let mut lines = BufReader::new(stdout).lines();
+                while let Ok(Some(line)) = lines.next_line().await {
+                    if line.contains("Pulling from")
+                        || line.contains("Digest")
+                        || line.contains("Status")
+                    {
+                        print.infoln(line);
+                    }
+                }
+            }
+        };
+
+        let capture_stderr = async {
+            let mut buf = String::new();
+            if let Some(mut stderr) = stderr {
+                let _ = stderr.read_to_string(&mut buf).await;
+            }
+            buf
+        };
+
+        // Drain both pipes concurrently so a full stderr buffer can't deadlock
+        // the child while we're reading stdout.
+        let ((), stderr) = tokio::join!(stream_stdout, capture_stderr);
+
+        if child.wait().await.map_err(|e| self.io_error(e))?.success() {
+            Ok(())
+        } else {
+            Err(Error::PullImageFailed {
+                image: image.to_string(),
+                stderr: stderr.trim().to_string(),
+            })
+        }
+    }
 }
 
 /// Resource limits for commands that *run* a container (e.g. `container start`).
@@ -498,7 +556,7 @@ mod test {
         let not_found = std::io::Error::from(std::io::ErrorKind::NotFound);
         match args(None, Some(Engine::AppleContainer)).io_error(not_found) {
             Error::NotFound { program, .. } => assert_eq!(program, "container"),
-            Error::Command { .. } => panic!("expected NotFound, got Command"),
+            other => panic!("expected NotFound, got {other:?}"),
         }
     }
 
diff --git a/cmd/soroban-cli/src/commands/contract/build.rs b/cmd/soroban-cli/src/commands/contract/build.rs
index 23b45af6e4..6d222aeec3 100644
--- a/cmd/soroban-cli/src/commands/contract/build.rs
+++ b/cmd/soroban-cli/src/commands/contract/build.rs
@@ -23,7 +23,7 @@ use crate::utils::XDR_DEPTH_LIMIT;
 use crate::{
     commands::{
         container::shared::{Args as ContainerArgs, RunArgs as ContainerRunArgs},
-        global, version, HEADING_CONTAINER,
+        global, version, HEADING_CONTAINER, HEADING_VERIFIABLE,
     },
     print::Print,
     wasm,
@@ -31,6 +31,7 @@ use crate::{
 
 pub mod container;
 pub(crate) mod source_archive;
+pub mod verifiable;
 
 /// A built WASM artifact with its package name and file path.
 #[derive(Debug, Clone)]
@@ -100,7 +101,11 @@ pub struct Cmd {
     pub locked: bool,
 
     /// Print commands to build without executing them
-    #[arg(long, conflicts_with = "out_dir", help_heading = "Other")]
+    ///
+    /// Incompatible with `--verifiable`, which compiles from a throwaway
+    /// extracted-archive tempdir that only exists for the build, so a printed
+    /// command bind-mounting it could never be replayed.
+    #[arg(long, conflicts_with_all = ["out_dir", "verifiable"], help_heading = "Other")]
     pub print_commands_only: bool,
 
     /// Build inside this container image (e.g.
@@ -122,6 +127,37 @@ pub struct Cmd {
     #[arg(long, requires = "image", help_heading = HEADING_CONTAINER)]
     pub pull: bool,
 
+    /// Produce a SEP-58 verifiable (reproducible) build.
+    ///
+    /// Snapshots the working tree into a byte-reproducible source archive,
+    /// builds it in a digest-pinned container image, and records provenance meta
+    /// (bldimg, source_uri, source_sha256, bldopt) into the wasm so a third
+    /// party can reproduce the exact bytes. Implies `--locked`. Requires a clean
+    /// git tree. Requires `--image` pinned by digest
+    /// (`<registry-host>/<repo>@sha256:<64-hex>`) so the recorded `bldimg` names
+    /// the exact bytes.
+    ///
+    /// Incompatible with `--print-commands-only`: a verifiable build compiles
+    /// from an extracted-archive tempdir that only exists for the build, so a
+    /// printed command bind-mounting it could never be replayed.
+    #[arg(long, requires = "image", help_heading = HEADING_VERIFIABLE)]
+    pub verifiable: bool,
+
+    /// Pin the SEP-58 source_sha256 of the generated archive (64-char lower-case
+    /// hex). The build fails if the archive hashes to a different value.
+    #[arg(long, requires = "verifiable", help_heading = HEADING_VERIFIABLE)]
+    pub source_sha256: Option<String>,
+
+    /// Record a SEP-58 source_uri where the source archive can be fetched (a URI
+    /// with a scheme, e.g. https://example.com/src.tar.gz).
+    #[arg(
+        long,
+        requires = "verifiable",
+        requires = "source_sha256",
+        help_heading = HEADING_VERIFIABLE
+    )]
+    pub source_uri: Option<String>,
+
     #[command(flatten)]
     pub build_args: BuildArgs,
 
@@ -245,6 +281,9 @@ pub enum Error {
 
     #[error(transparent)]
     Container(#[from] container::Error),
+
+    #[error(transparent)]
+    Verifiable(#[from] verifiable::Error),
 }
 
 pub(crate) const WASM_TARGET: &str = "wasm32v1-none";
@@ -265,6 +304,9 @@ impl Default for Cmd {
             print_commands_only: false,
             image: None,
             pull: false,
+            verifiable: false,
+            source_sha256: None,
+            source_uri: None,
             build_args: BuildArgs::default(),
             container_args: ContainerArgs::default(),
             run_args: ContainerRunArgs::default(),
@@ -278,7 +320,14 @@ impl Cmd {
     pub async fn run(&self, global_args: &global::Args) -> Result<Vec<BuiltContract>, Error> {
         let print = Print::new(global_args.quiet);
 
-        // When an image is given, build inside that container instead of locally.
+        // A verifiable build archives the source and builds it in a
+        // digest-pinned container, recording SEP-58 provenance meta.
+        if self.verifiable {
+            return verifiable::run(self, global_args, &print).await;
+        }
+
+        // When an image is given (without --verifiable), build inside that
+        // container instead of locally.
         if self.image.is_some() {
             return container::run(self, global_args, &print).await;
         }
diff --git a/cmd/soroban-cli/src/commands/contract/build/container.rs b/cmd/soroban-cli/src/commands/contract/build/container.rs
index c6299e9985..30ec3b1d1c 100644
--- a/cmd/soroban-cli/src/commands/contract/build/container.rs
+++ b/cmd/soroban-cli/src/commands/contract/build/container.rs
@@ -27,18 +27,18 @@ use super::{get_wasm_target, BuiltContract, Cmd, WASM_TARGET, WASM_TARGET_OLD};
 /// First CLI release whose `contract build` accepts `--locked` (added in cli
 /// v25.2.0). Older images reject it, so it's dropped (with a warning) on anything
 /// older, matching the version detected from the image's own `version` output.
-const LOCKED_MIN: &str = "25.2.0";
+pub(super) const LOCKED_MIN: &str = "25.2.0";
 
 /// First CLI release whose `contract build` has the `--optimize` flag at all.
 /// Older images reject it, so — since optimization is on by default — this is the
 /// effective minimum supported image. We probe the image's `version` and skip the
 /// flag (with a warning) on anything older.
-const OPTIMIZE_FLAG_MIN: &str = "23.2.0";
+pub(super) const OPTIMIZE_FLAG_MIN: &str = "23.2.0";
 
 /// First CLI release whose `contract build` accepts `--optimize=false` as an
 /// explicit value. Images between [`OPTIMIZE_FLAG_MIN`] and this default to *not*
 /// optimizing, so for them we forward nothing to get an unoptimized build.
-const OPTIMIZE_NEW_SYNTAX_MIN: &str = "26.1.0";
+pub(super) const OPTIMIZE_NEW_SYNTAX_MIN: &str = "26.1.0";
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
@@ -156,14 +156,18 @@ pub async fn run(
     let container_cmds: Vec<Vec<String>> = targets
         .iter()
         .map(|target| {
+            // Plain container builds forward the user's `--locked` (when the
+            // image accepts it) and don't record bldopts.
             forwarded_build_args(
                 cmd,
                 &workspace_root,
                 *target,
-                supports_locked,
+                cmd.locked && supports_locked,
                 supports_optimize_flag,
                 supports_optimize_false,
+                false,
             )
+            .0
         })
         .collect();
 
@@ -201,6 +205,7 @@ pub async fn run(
         &docker,
         &cmd.run_args,
         &bin,
+        "stellar-contract-build",
         print,
         print_only,
     )
@@ -211,10 +216,10 @@ pub async fn run(
         return Ok(Vec::new());
     }
 
-    collect_built_contracts(cmd, &md, &workspace_root)
+    collect_built_contracts(cmd, &md, &workspace_root, None)
 }
 
-fn metadata(cmd: &Cmd) -> Result<cargo_metadata::Metadata, cargo_metadata::Error> {
+pub(super) fn metadata(cmd: &Cmd) -> Result<cargo_metadata::Metadata, cargo_metadata::Error> {
     let mut mc = MetadataCommand::new();
     mc.no_deps();
     if let Some(p) = &cmd.manifest_path {
@@ -227,7 +232,7 @@ fn metadata(cmd: &Cmd) -> Result<cargo_metadata::Metadata, cargo_metadata::Error
 /// default-member crates that build a cdylib, mirroring the local build's
 /// package selection. May be empty (no cdylib default members), in which case
 /// the caller falls back to a single no-`--package` build.
-fn resolve_packages(cmd: &Cmd, md: &cargo_metadata::Metadata) -> Vec<String> {
+pub(super) fn resolve_packages(cmd: &Cmd, md: &cargo_metadata::Metadata) -> Vec<String> {
     if let Some(pkg) = &cmd.package {
         return vec![pkg.clone()];
     }
@@ -248,13 +253,16 @@ fn resolve_packages(cmd: &Cmd, md: &cargo_metadata::Metadata) -> Vec<String> {
 }
 
 /// The `contract build …` argv forwarded to the container, mirroring the local
-/// build's flags. `--manifest-path` is relativized against the workspace root so
-/// it's valid inside `/source`. `--out-dir` is deliberately omitted — artifacts
-/// are collected on the host from the mounted `target/`.
+/// build's flags, plus (when `record_bldopts`) the shell-escaped `bldopt`
+/// strings recorded into SEP-58 metadata by verifiable builds. `--manifest-path`
+/// is relativized against the workspace/source root so it's valid inside
+/// `/source`. `--out-dir` is deliberately omitted — artifacts are collected on
+/// the host from the mounted `target/`.
 ///
-/// `supports_locked`: whether the container's `contract build` accepts `--locked`
-/// (added in cli 25.2.0). When false, the user's `--locked` is dropped rather
-/// than forwarded to an image that would reject it.
+/// `include_locked`: whether to add `--locked`. A plain container build passes
+/// `cmd.locked && supports_locked` (the user's flag, when the image accepts it);
+/// a verifiable build implies it (`supports_locked`). Either way it's dropped on
+/// images too old to accept the flag (added in cli 25.2.0).
 ///
 /// `supports_optimize_flag`: whether the container's cli has the `--optimize`
 /// flag at all (added in cli 23.2.0). When false, nothing about optimize is
@@ -264,18 +272,47 @@ fn resolve_packages(cmd: &Cmd, md: &cargo_metadata::Metadata) -> Vec<String> {
 /// `--optimize=false` (added in cli 26.1.0). When false and the user disabled
 /// optimization, nothing is forwarded — the older cli defaults to not
 /// optimizing, and passing `--optimize=false` there would fail.
-fn forwarded_build_args(
+///
+/// `record_bldopts`: when true, every forwarded build-affecting flag is also
+/// captured as a `bldopt` (its value shell-escaped once, at the source, so each
+/// recorded option is valid shell on its own) for the verifiable build's SEP-58
+/// metadata. A plain container build passes false and ignores the second tuple
+/// element.
+#[allow(clippy::too_many_arguments, clippy::fn_params_excessive_bools)]
+pub(super) fn forwarded_build_args(
     cmd: &Cmd,
     workspace_root: &Path,
     package: Option<&str>,
-    supports_locked: bool,
+    include_locked: bool,
     supports_optimize_flag: bool,
     supports_optimize_false: bool,
-) -> Vec<String> {
+    record_bldopts: bool,
+) -> (Vec<String>, Vec<String>) {
     let mut args = vec!["contract".to_string(), "build".to_string()];
+    let mut bldopts: Vec<String> = Vec::new();
+
+    // Record a build option. `None` means a bare flag (`--locked`); `Some(v)`
+    // means `--flag=v`. The forwarded copy keeps the value raw (the container
+    // gets it as argv, and `compose_shell_command` re-escapes it for the
+    // multi-package `sh -c`); the bldopt copy shell-escapes only the value side,
+    // once, so every recorded option is valid shell on its own — e.g.
+    // `--meta=note='added on build'`, never `'--meta=note=added on build'`.
+    let mut record = |key: &str, value: Option<&str>| {
+        if let Some(v) = value {
+            args.push(format!("{key}={v}"));
+            if record_bldopts {
+                bldopts.push(format!("{key}={}", shell_escape::escape(v.into())));
+            }
+        } else {
+            args.push(key.to_string());
+            if record_bldopts {
+                bldopts.push(key.to_string());
+            }
+        }
+    };
 
-    if cmd.locked && supports_locked {
-        args.push("--locked".to_string());
+    if include_locked {
+        record("--locked", None);
     }
     if let Some(path) = &cmd.manifest_path {
         let abs = std::path::absolute(path).unwrap_or_else(|_| path.clone());
@@ -283,25 +320,25 @@ fn forwarded_build_args(
             .strip_prefix(workspace_root)
             .map(Path::to_path_buf)
             .unwrap_or(abs);
-        args.push(format!("--manifest-path={}", rel.to_slash_lossy()));
+        record("--manifest-path", Some(rel.to_slash_lossy().as_ref()));
     }
     if cmd.profile != "release" {
-        args.push(format!("--profile={}", cmd.profile));
+        record("--profile", Some(cmd.profile.as_str()));
     }
     if let Some(features) = &cmd.features {
-        args.push(format!("--features={features}"));
+        record("--features", Some(features.as_str()));
     }
     if cmd.all_features {
-        args.push("--all-features".to_string());
+        record("--all-features", None);
     }
     if cmd.no_default_features {
-        args.push("--no-default-features".to_string());
+        record("--no-default-features", None);
     }
     if let Some(pkg) = package {
-        args.push(format!("--package={pkg}"));
+        record("--package", Some(pkg));
     }
     for (k, v) in &cmd.build_args.meta {
-        args.push(format!("--meta={k}={v}"));
+        record(&format!("--meta={k}"), Some(v.as_str()));
     }
     // Optimization is forwarded per the image's cli version. To enable it, bare
     // `--optimize` on images >= v23.2.0 (older images lack the flag entirely, so
@@ -309,13 +346,13 @@ fn forwarded_build_args(
     // older ones default to not optimizing, so forwarding nothing matches.
     if cmd.build_args.optimize {
         if supports_optimize_flag {
-            args.push("--optimize".to_string());
+            record("--optimize", None);
         }
     } else if supports_optimize_false {
-        args.push("--optimize=false".to_string());
+        record("--optimize", Some("false"));
     }
 
-    args
+    (args, bldopts)
 }
 
 async fn pull_image(docker: &shared::Args, image: &str, print: &Print) -> Result<(), Error> {
@@ -364,18 +401,18 @@ async fn run_probe(
 
 /// Facts probed from the image before building, gathered in one throwaway
 /// container to avoid a round-trip per fact.
-struct ImageProbe {
+pub(super) struct ImageProbe {
     /// CLI binary on the image's PATH — `stellar` (v21.0.0+) or `soroban`
     /// (older). Used when invoking the CLI by name in the chained multi-build
     /// command; the single-build path uses the image's entrypoint instead.
-    bin: String,
+    pub(super) bin: String,
     /// Parsed CLI version, or `None` when the image reported no parseable version
     /// (treated as a current image by the caller).
-    version: Option<Version>,
+    pub(super) version: Option<Version>,
     /// The image's default rustup toolchain (e.g.
     /// `1.97.1-aarch64-unknown-linux-gnu`), pinned into `RUSTUP_TOOLCHAIN`.
     /// Guaranteed non-empty — the probe hard-fails when it can't be determined.
-    toolchain: String,
+    pub(super) toolchain: String,
 }
 
 /// Probe the image once for everything the build needs: the CLI binary name, its
@@ -384,7 +421,7 @@ struct ImageProbe {
 /// already require) that detects the binary, then reports each fact on its own
 /// tagged line so the combined stdout can be split apart. Hard-fails when no
 /// default toolchain can be determined, rather than building unpinned.
-async fn probe_image(image: &str, docker: &shared::Args) -> Result<ImageProbe, Error> {
+pub(super) async fn probe_image(image: &str, docker: &shared::Args) -> Result<ImageProbe, Error> {
     // Detect the binary first, then run `$bin version` (version on its first
     // line) and `rustup default` (the toolchain name). Tag each line so we can
     // pick the values back out regardless of any extra output.
@@ -446,7 +483,7 @@ fn parse_default_toolchain(stdout: &str) -> Option<String> {
 }
 
 #[allow(clippy::too_many_arguments)]
-async fn run_in_container(
+pub(super) async fn run_in_container(
     image: &str,
     workspace_root: &Path,
     container_cmds: &[Vec<String>],
@@ -454,6 +491,7 @@ async fn run_in_container(
     docker: &shared::Args,
     run_args: &shared::RunArgs,
     bin: &str,
+    container_name_prefix: &str,
     print: &Print,
     print_only: bool,
 ) -> Result<(), Error> {
@@ -513,7 +551,7 @@ async fn run_in_container(
     // per invocation so concurrent builds don't collide, and kept out of the
     // reproduce line where a fixed name would clash on re-run.
     let container_name = format!(
-        "stellar-contract-build-{}-{:08x}",
+        "{container_name_prefix}-{}-{:08x}",
         std::process::id(),
         rand::random::<u32>()
     );
@@ -698,17 +736,39 @@ fn newest_existing_artifact(candidates: &[PathBuf]) -> Option<PathBuf> {
         .cloned()
 }
 
-/// Collect the built wasm from the mounted `target/`. Because the working tree
-/// was bind-mounted, the container writes artifacts straight to the host under
-/// `<workspace>/target/<triple>/<profile>/`. The container's rust toolchain
-/// decides the target triple, so both known triples are probed. Copies to
-/// `--out-dir` when set.
-fn collect_built_contracts(
+/// Collect the built wasm artifacts. Package names and the host target dir come
+/// from host `cargo metadata`.
+///
+/// `extracted_root` is `None` for a plain container build: the working tree was
+/// bind-mounted, so the container wrote artifacts straight to the host target
+/// dir and they're read (and optionally copied to `--out-dir`) in place. It's
+/// `Some(er)` for a verifiable build, where the container built from an
+/// extracted-archive tempdir; the artifacts then live under that tree's target
+/// dir and must be copied back to the host target dir (or `--out-dir`) before
+/// the tempdir drops. `source_root` is the host source root the extracted tree
+/// mirrors, so the target dir's position relative to it carries over.
+///
+/// The container's rust toolchain decides the target triple, so both known
+/// triples are probed and the *freshest* artifact wins (an earlier build into
+/// the other triple can leave a stale wasm behind).
+pub(super) fn collect_built_contracts(
     cmd: &Cmd,
     md: &cargo_metadata::Metadata,
-    workspace_root: &Path,
+    source_root: &Path,
+    extracted_root: Option<&Path>,
 ) -> Result<Vec<BuiltContract>, super::Error> {
-    let target_root = workspace_root.join("target");
+    // Where the user's artifacts ultimately belong (and where a verifiable build's
+    // wasm is copied back to): the workspace's real target dir, which may be moved
+    // by a `.cargo/config.toml` `target-dir` or host `CARGO_TARGET_DIR`.
+    let host_target = md.target_directory.as_std_path();
+
+    // Where the build ACTUALLY wrote artifacts. The container is always forced to
+    // `CARGO_TARGET_DIR=/source/target` (independent of the host's target-dir
+    // config), which on the host is `<bind-mounted dir>/target` — the extracted
+    // archive root for a verifiable build, else the source (workspace) root. Basing
+    // this on `host_target` instead would miss the artifacts whenever a custom
+    // target-dir moves it away from `<source>/target`.
+    let src_target = extracted_root.unwrap_or(source_root).join("target");
 
     let mut out = Vec::new();
     for p in &md.packages {
@@ -728,30 +788,48 @@ fn collect_built_contracts(
         }
 
         let file = format!("{}.wasm", p.name.replace('-', "_"));
-        // The container may build for either wasm target depending on its rust
-        // version, so probe both triple dirs. Pick the *freshest* rather than the
-        // first that exists: an earlier build into the other triple can leave a
-        // stale wasm behind, and selecting by existence alone would return it.
-        // Fall back to the current host default for the reported path when the
-        // build produced nothing.
-        let candidates: Vec<PathBuf> = [WASM_TARGET, WASM_TARGET_OLD]
+        // Probe both triple dirs (the container's rust version decides which),
+        // picking the freshest by mtime rather than the first that exists. The
+        // chosen triple's relative path is reused to mirror the layout when
+        // copying a verifiable build's artifact back to the host target dir.
+        let rel_candidates: Vec<PathBuf> = [WASM_TARGET, WASM_TARGET_OLD]
             .iter()
-            .map(|triple| target_root.join(triple).join(&cmd.profile).join(&file))
+            .map(|triple| Path::new(triple).join(&cmd.profile).join(&file))
             .collect();
-        let src = newest_existing_artifact(&candidates).unwrap_or_else(|| {
-            let triple = get_wasm_target().unwrap_or_else(|_| WASM_TARGET.to_string());
-            target_root.join(triple).join(&cmd.profile).join(&file)
-        });
+        let abs_candidates: Vec<PathBuf> = rel_candidates
+            .iter()
+            .map(|rel| src_target.join(rel))
+            .collect();
+        let chosen_rel = newest_existing_artifact(&abs_candidates)
+            .and_then(|src| src.strip_prefix(&src_target).ok().map(Path::to_path_buf))
+            .unwrap_or_else(|| {
+                let triple = get_wasm_target().unwrap_or_else(|_| WASM_TARGET.to_string());
+                Path::new(&triple).join(&cmd.profile).join(&file)
+            });
+        let src = src_target.join(&chosen_rel);
+
+        // Destination: `--out-dir` wins; else if the build ran in an extracted
+        // tempdir, copy into the host target dir so the artifact survives the
+        // tempdir drop; else leave it in place (already on the host).
+        let dest = if let Some(out_dir) = &cmd.out_dir {
+            Some(out_dir.join(&file))
+        } else if extracted_root.is_some() {
+            Some(host_target.join(&chosen_rel))
+        } else {
+            None
+        };
 
-        let path = if let Some(out_dir) = &cmd.out_dir {
-            std::fs::create_dir_all(out_dir).map_err(super::Error::CreatingOutDir)?;
-            let dest = out_dir.join(&file);
-            if src.exists() {
+        let path = match dest {
+            Some(dest) if src.exists() => {
+                if let Some(parent) = dest.parent() {
+                    std::fs::create_dir_all(parent).map_err(super::Error::CreatingOutDir)?;
+                }
                 std::fs::copy(&src, &dest).map_err(super::Error::CopyingWasmFile)?;
+                dest
             }
-            dest
-        } else {
-            src
+            // Source missing: report the intended dest (matches prior leniency).
+            Some(dest) => dest,
+            None => src,
         };
 
         out.push(BuiltContract {
@@ -778,12 +856,14 @@ mod tests {
     #[test]
     fn forwarded_build_args_defaults() {
         let cmd = Cmd::default();
-        let args = forwarded_build_args(&cmd, &ws(), None, true, true, true);
+        let (args, bldopts) = forwarded_build_args(&cmd, &ws(), None, false, true, true, false);
         assert_eq!(args[..2], ["contract".to_string(), "build".to_string()]);
         // Default optimize=true → bare `--optimize`; no `--locked` unless asked.
         assert!(args.contains(&"--optimize".to_string()));
         assert!(!args.iter().any(|a| a == "--locked"));
         assert!(!args.iter().any(|a| a.starts_with("--package")));
+        // Plain container builds don't record bldopts.
+        assert!(bldopts.is_empty());
     }
 
     #[test]
@@ -792,19 +872,21 @@ mod tests {
             locked: true,
             ..Cmd::default()
         };
-        let args = forwarded_build_args(&cmd, &ws(), Some("contract-a"), true, true, true);
+        let (args, _) =
+            forwarded_build_args(&cmd, &ws(), Some("contract-a"), true, true, true, false);
         assert!(args.contains(&"--locked".to_string()));
         assert!(args.contains(&"--package=contract-a".to_string()));
     }
 
     #[test]
     fn forwarded_build_args_drops_locked_when_unsupported() {
-        // User asked for --locked but the image's cli doesn't accept it.
+        // User asked for --locked but the image's cli doesn't accept it, so the
+        // caller passes include_locked=false (cmd.locked && supports_locked).
         let cmd = Cmd {
             locked: true,
             ..Cmd::default()
         };
-        let args = forwarded_build_args(&cmd, &ws(), None, false, true, true);
+        let (args, _) = forwarded_build_args(&cmd, &ws(), None, false, true, true, false);
         assert!(!args.iter().any(|a| a == "--locked"));
     }
 
@@ -814,7 +896,7 @@ mod tests {
         // though optimize defaults to true.
         let cmd = Cmd::default();
         assert!(cmd.build_args.optimize);
-        let args = forwarded_build_args(&cmd, &ws(), None, true, false, false);
+        let (args, _) = forwarded_build_args(&cmd, &ws(), None, false, false, false, false);
         assert!(!args.iter().any(|a| a.starts_with("--optimize")));
     }
 
@@ -834,7 +916,7 @@ mod tests {
             },
             ..Cmd::default()
         };
-        let args = forwarded_build_args(&cmd, &ws(), None, true, true, true);
+        let (args, _) = forwarded_build_args(&cmd, &ws(), None, false, true, true, false);
         assert!(args.contains(&"--profile=dev".to_string()));
         assert!(args.contains(&"--features=a,b".to_string()));
         assert!(args.contains(&"--all-features".to_string()));
@@ -844,6 +926,32 @@ mod tests {
         assert!(args.contains(&"--optimize=false".to_string()));
     }
 
+    #[test]
+    fn forwarded_build_args_records_bldopts_when_requested() {
+        // Verifiable builds pass record_bldopts=true and include_locked=true,
+        // capturing each forwarded flag as a shell-escaped bldopt.
+        let cmd = Cmd {
+            features: Some("a,b".to_string()),
+            build_args: BuildArgs {
+                meta: vec![("note".to_string(), "added on build".to_string())],
+                optimize: true,
+            },
+            ..Cmd::default()
+        };
+        let (forwarded, bldopts) =
+            forwarded_build_args(&cmd, &ws(), Some("contract-a"), true, true, true, true);
+        assert!(forwarded.contains(&"--locked".to_string()));
+        assert!(forwarded.contains(&"--meta=note=added on build".to_string()));
+        assert!(bldopts.contains(&"--locked".to_string()));
+        assert!(bldopts.contains(&"--features=a,b".to_string()));
+        assert!(bldopts.contains(&"--package=contract-a".to_string()));
+        // Only the value side is shell-escaped, and each bldopt is one token.
+        assert!(bldopts.contains(&"--meta=note='added on build'".to_string()));
+        for o in &bldopts {
+            assert_eq!(shlex::split(o).expect("valid shell").len(), 1, "{o}");
+        }
+    }
+
     #[test]
     fn forwarded_build_args_optimize_false_old_image_forwards_nothing() {
         // Old image defaults to not optimizing and rejects `--optimize=false`,
@@ -855,7 +963,7 @@ mod tests {
             },
             ..Cmd::default()
         };
-        let args = forwarded_build_args(&cmd, &ws(), None, true, true, false);
+        let (args, _) = forwarded_build_args(&cmd, &ws(), None, false, true, false, false);
         assert!(!args.iter().any(|a| a.starts_with("--optimize")));
     }
 
@@ -865,7 +973,7 @@ mod tests {
             manifest_path: Some(PathBuf::from("/tmp/ws/contracts/add/Cargo.toml")),
             ..Cmd::default()
         };
-        let args = forwarded_build_args(&cmd, &ws(), None, true, true, true);
+        let (args, _) = forwarded_build_args(&cmd, &ws(), None, false, true, true, false);
         assert!(args.contains(&"--manifest-path=contracts/add/Cargo.toml".to_string()));
     }
 
diff --git a/cmd/soroban-cli/src/commands/contract/build/source_archive.rs b/cmd/soroban-cli/src/commands/contract/build/source_archive.rs
index 9afc657a82..588f8ce384 100644
--- a/cmd/soroban-cli/src/commands/contract/build/source_archive.rs
+++ b/cmd/soroban-cli/src/commands/contract/build/source_archive.rs
@@ -350,21 +350,21 @@ fn gzip(bytes: &[u8]) -> Result<Vec<u8>, Error> {
     })
 }
 
+/// Decompress gzip and unpack the tar into `dest`. Entries are `source/…`, so
+/// they land at `<dest>/source/…`.
+pub(crate) fn unpack_targz(bytes: &[u8], dest: &Path) -> Result<(), Error> {
+    let dec = flate2::read::GzDecoder::new(bytes);
+    tar::Archive::new(dec)
+        .unpack(dest)
+        .map_err(Error::ArchiveExtract)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::config::locator::enforce_hardened_tree;
     use sha2::{Digest, Sha256};
 
-    /// Decompress gzip and unpack the tar into `dest`. Entries are `source/…`,
-    /// so they land at `<dest>/source/…`.
-    fn unpack_targz(bytes: &[u8], dest: &Path) -> Result<(), Error> {
-        let dec = flate2::read::GzDecoder::new(bytes);
-        tar::Archive::new(dec)
-            .unpack(dest)
-            .map_err(Error::ArchiveExtract)
-    }
-
     #[test]
     fn is_warned_matches_names_and_dotted_suffixes() {
         use std::ffi::OsStr;
diff --git a/cmd/soroban-cli/src/commands/contract/build/verifiable.rs b/cmd/soroban-cli/src/commands/contract/build/verifiable.rs
new file mode 100644
index 0000000000..06153c3b18
--- /dev/null
+++ b/cmd/soroban-cli/src/commands/contract/build/verifiable.rs
@@ -0,0 +1,577 @@
+//! Verifiable (SEP-58 reproducible) contract builds.
+//!
+//! Triggered by `stellar contract build --verifiable`. Unlike the plain
+//! `--image` container build, this snapshots the working tree into a
+//! byte-reproducible source archive, hashes it (`source_sha256`), extracts it
+//! into a permission-hardened tempdir, and builds *that* in a digest-pinned
+//! image — recording SEP-58 provenance meta (`bldimg`, `source_uri`,
+//! `source_sha256`, `bldopt`) into the wasm so a third party can reproduce the
+//! exact bytes.
+//!
+//! The container execution machinery (image probe, `run_in_container`,
+//! reproduce lines, artifact collection) is shared with
+//! [`super::container`]; this module adds the archive and the SEP-58 metadata
+//! on top. The build image is the user-supplied, digest-pinned `--image`.
+
+use std::path::{Path, PathBuf};
+
+use regex::Regex;
+use semver::Version;
+use sha2::{Digest, Sha256};
+use soroban_spec_tools::sanitize;
+
+use crate::{
+    commands::{
+        container::shared::{self, Error as ConnectionError},
+        global,
+    },
+    config::{
+        data,
+        locator::{enforce_hardened_tree, write_hardened_file},
+    },
+    print::Print,
+};
+
+use super::{container, source_archive, BuiltContract, Cmd};
+
+const RESERVED_META_KEYS: &[&str] = &["bldimg", "source_uri", "source_sha256", "bldopt"];
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    DockerConnection(#[from] ConnectionError),
+
+    #[error("--image value {value:?} does not match the SEP-58 bldimg format `<registry-host>/<repo>@sha256:<64-hex>`. Examples: docker.io/stellar/stellar-cli@sha256:<64-hex>, localhost:5000/foo@sha256:<64-hex>. Tag-only refs and implicit Docker-Hub short refs are not accepted.")]
+    BldimgFormat { value: String },
+
+    #[error(transparent)]
+    SourceArchive(#[from] source_archive::Error),
+
+    #[error(
+        "the cli sets bldimg, source_uri, source_sha256, and bldopt automatically when --verifiable is used; remove them from --meta. Got reserved key: {key}"
+    )]
+    ReservedMetaKey { key: String },
+
+    #[error("--source-sha256 value {value:?} does not match the SEP-58 source_sha256 format `^[0-9a-f]{{64}}$` (64-char lower-case hex).")]
+    SourceSha256Format { value: String },
+
+    #[error("--source-uri value {value:?} does not match the SEP-58 source_uri format `^[a-zA-Z][a-zA-Z0-9+.-]*:\\S+$` (a URI with a scheme, e.g. https://example.com/src.tar.gz).")]
+    SourceUriFormat { value: String },
+
+    #[error("--source-sha256 {provided} does not match the SHA-256 of the generated archive {computed}. Omit --source-sha256 to record the computed value, or fix the value.")]
+    SourceSha256Mismatch { provided: String, computed: String },
+
+    #[error("SEP-58 metadata must be ASCII, but {field} contains non-ASCII characters: {value}. Use an ASCII value (e.g. a punycode/percent-encoded URI).")]
+    NonAsciiMeta { field: String, value: String },
+
+    #[error(transparent)]
+    Data(#[from] data::Error),
+}
+
+pub async fn run(
+    cmd: &Cmd,
+    global_args: &global::Args,
+    print: &Print,
+) -> Result<Vec<BuiltContract>, super::Error> {
+    let _ = global_args;
+
+    // Stage 1: pure validation, no I/O.
+    for (k, _) in &cmd.build_args.meta {
+        if RESERVED_META_KEYS.iter().any(|r| r == k) {
+            return Err(Error::ReservedMetaKey { key: k.clone() }.into());
+        }
+    }
+    if let Some(img) = &cmd.image {
+        validate_image(img)?;
+    }
+
+    // Stage 2: local filesystem + git, no network.
+    validate_source_formats(cmd)?;
+
+    // The source root is the current working directory: it's archived,
+    // bind-mounted into the container, and the `--manifest-path` bldopt is
+    // relativized against it. Run from the project/workspace root you want built.
+    let source_root = source_archive::resolve_source_root();
+
+    // The archive is the working tree, so refuse a dirty repo: a verifiable build
+    // should be deliberate, off a committed state, not whatever happens to be on
+    // disk. Skipped when the source root isn't a git repo.
+    source_archive::ensure_clean_tree(&source_root, print).map_err(Error::from)?;
+
+    // Build the source archive, record its hash, and build from the *extracted*
+    // archive (in a hardened tempdir) so the wasm is produced from exactly the
+    // bytes that were hashed.
+    let resolved = {
+        let a = resolve_archive(cmd, &source_root, print)?;
+        // The extracted `source/` dir mirrors `source_root` exactly and is both
+        // the container mount and the tree the build writes `target/` into.
+        let mount_root = a.extracted_root.join("source");
+        ResolvedSource {
+            source_sha256: a.source_sha256,
+            extracted_root: Some(mount_root.clone()),
+            mount_root,
+            _tmp: Some(a.tmp),
+        }
+    };
+
+    let source_ids = SourceIds {
+        source_uri: cmd.source_uri.clone(),
+        source_sha256: Some(resolved.source_sha256.clone()),
+    };
+
+    // Stage 3: the container engine.
+    let docker = cmd.container_args.clone();
+    docker.warn_if_host_ignored(print);
+    let image_ref = resolve_image(cmd, &docker, print).await?;
+
+    // Probe the pinned image once for its cli binary, version, and default
+    // toolchain (shared with the plain container build), then gate flags on the
+    // reported version.
+    let probe = container::probe_image(&image_ref, &docker).await?;
+    let cli_version = probe.version.clone();
+    let at_least = |min: &str| {
+        cli_version
+            .as_ref()
+            .is_none_or(|v| *v >= Version::parse(min).unwrap())
+    };
+    let supports_locked = at_least(container::LOCKED_MIN);
+    let supports_optimize_flag = at_least(container::OPTIMIZE_FLAG_MIN);
+    let supports_optimize_false = at_least(container::OPTIMIZE_NEW_SYNTAX_MIN);
+
+    // `--locked` is implied by `--verifiable` (a reproducible build should pin
+    // the lockfile), but it was only added to `contract build` in cli 25.2.0.
+    if supports_locked {
+        if !cmd.locked {
+            print.infoln("Implying --locked because --verifiable was passed");
+        }
+    } else {
+        print.warnln(
+            "The build image's `contract build` does not support --locked; \
+             building without it. Dependency drift may affect reproducibility.",
+        );
+    }
+
+    // Resolve host `cargo metadata` once and reuse it for package selection and
+    // artifact collection, mirroring the plain container build.
+    let md = container::metadata(cmd).map_err(container::Error::Metadata)?;
+
+    // Build once per package, each with its own `--package` forwarded and
+    // recorded as a `bldopt`, so every wasm is independently reproducible.
+    let packages = container::resolve_packages(cmd, &md);
+    if cmd.package.is_none() && !packages.is_empty() {
+        print.infoln(format!("Inferred packages: {}", packages.join(", ")));
+    }
+    let targets: Vec<Option<&str>> = if packages.is_empty() {
+        vec![None]
+    } else {
+        packages.iter().map(|p| Some(p.as_str())).collect()
+    };
+    let container_cmds: Vec<Vec<String>> = targets
+        .iter()
+        .map(|target| {
+            // Verifiable implies `--locked` (when supported) and records every
+            // build-affecting flag as a `bldopt`.
+            let (mut args, bldopts) = container::forwarded_build_args(
+                cmd,
+                &source_root,
+                *target,
+                supports_locked,
+                supports_optimize_flag,
+                supports_optimize_false,
+                true,
+            );
+            args.extend(build_metadata_args(&image_ref, &source_ids, &bldopts));
+            args
+        })
+        .collect();
+
+    // Pin the target dir to a known location under the mount, and the image's
+    // own default toolchain so a `rust-toolchain.toml` in the source can't
+    // redirect the build to a toolchain rustup would then try to install.
+    let mut env = vec!["CARGO_TARGET_DIR=/source/target".to_string()];
+    print.infoln(format!("Using Rust toolchain {}", probe.toolchain));
+    env.push(format!("RUSTUP_TOOLCHAIN={}", probe.toolchain));
+
+    container::run_in_container(
+        &image_ref,
+        &resolved.mount_root,
+        &container_cmds,
+        &env,
+        &docker,
+        &cmd.run_args,
+        &probe.bin,
+        "stellar-verifiable-build",
+        print,
+        cmd.print_commands_only,
+    )
+    .await?;
+
+    // Nothing was built when only printing the command.
+    if cmd.print_commands_only {
+        return Ok(Vec::new());
+    }
+
+    container::collect_built_contracts(cmd, &md, &source_root, resolved.extracted_root.as_deref())
+}
+
+/// The recorded `source_sha256`, the directory bind-mounted at `/source`, the
+/// extracted-archive root, and its tempdir guard — held so the temp dir
+/// outlives the container build and artifact collection.
+struct ResolvedSource {
+    source_sha256: String,
+    mount_root: PathBuf,
+    extracted_root: Option<PathBuf>,
+    _tmp: Option<tempfile::TempDir>,
+}
+
+/// Source-identification fields recorded as SEP-58 meta. `source_sha256` is
+/// always `Some` by the time these are built in `run()` (computed from the
+/// generated archive). `source_uri` is `Some` only when the user passed
+/// `--source-uri`.
+#[derive(Debug, Default, Clone)]
+struct SourceIds {
+    source_uri: Option<String>,
+    source_sha256: Option<String>,
+}
+
+/// Format-validate the user-supplied source flags. Both are optional under
+/// `--verifiable`; `--source-sha256`, when present, is validated as a pin in
+/// `resolve_archive`.
+fn validate_source_formats(cmd: &Cmd) -> Result<(), Error> {
+    if let Some(sha) = &cmd.source_sha256 {
+        if !source_sha256_regex().is_match(sha) {
+            return Err(Error::SourceSha256Format { value: sha.clone() });
+        }
+    }
+    if let Some(uri) = &cmd.source_uri {
+        // SEP-58 metadata is ASCII, but the URI regex's `\S` is Unicode-aware, so
+        // guard explicitly before the format check.
+        if !uri.is_ascii() {
+            return Err(Error::NonAsciiMeta {
+                field: "source_uri".to_string(),
+                value: sanitize(uri),
+            });
+        }
+        if !source_uri_regex().is_match(uri) {
+            return Err(Error::SourceUriFormat { value: uri.clone() });
+        }
+    }
+    Ok(())
+}
+
+/// Validate the SEP-58 `bldimg` (`--image`): it must be ASCII (the format regex
+/// is Unicode-aware, so guard explicitly) and match the digest-pinned format.
+/// The offending value is sanitized for display.
+fn validate_image(image: &str) -> Result<(), Error> {
+    if !image.is_ascii() {
+        return Err(Error::NonAsciiMeta {
+            field: "bldimg".to_string(),
+            value: sanitize(image),
+        });
+    }
+    if !bldimg_regex().is_match(image) {
+        return Err(Error::BldimgFormat {
+            value: image.to_string(),
+        });
+    }
+    Ok(())
+}
+
+/// Outcome of archiving: the generated archive's SHA-256 and the directory it
+/// was extracted into (held alive by `tmp`).
+struct ArchiveResult {
+    source_sha256: String,
+    extracted_root: PathBuf,
+    tmp: tempfile::TempDir,
+}
+
+/// Build the source archive, record its hash, write it to the managed archives
+/// dir (content-addressed, so the bytes are available to upload for
+/// `--source-uri`), and extract it into a permission-hardened tempdir that the
+/// container then builds from.
+fn resolve_archive(cmd: &Cmd, source_root: &Path, print: &Print) -> Result<ArchiveResult, Error> {
+    let bytes = source_archive::build_source_archive(source_root, print, true, None)?;
+    let computed = hex::encode(Sha256::digest(&bytes));
+
+    // If the user pinned a hash, it must match what we produced.
+    if let Some(provided) = &cmd.source_sha256 {
+        if provided != &computed {
+            return Err(Error::SourceSha256Mismatch {
+                provided: provided.clone(),
+                computed,
+            });
+        }
+    }
+
+    // Content-addressed name under the managed archives dir. The archive is the
+    // whole working tree, so it can hold private source or an unignored `.env`;
+    // write it `0600` (never the umask default `0644`) so it isn't world-readable.
+    let out_path = data::archives_dir()?.join(format!("{computed}.tar.gz"));
+    if let Some(parent) = out_path.parent() {
+        std::fs::create_dir_all(parent).map_err(|source| source_archive::Error::ArchiveWrite {
+            path: out_path.clone(),
+            source,
+        })?;
+    }
+    write_hardened_file(&out_path, &bytes).map_err(|source| {
+        source_archive::Error::ArchiveWrite {
+            path: out_path.clone(),
+            source,
+        }
+    })?;
+    print.infoln(format!(
+        "Wrote source archive {} (source_sha256 {computed})",
+        out_path.display()
+    ));
+
+    // Extract and harden, then build from the extracted copy so the wasm is
+    // produced from exactly the archived bytes.
+    //
+    // Extract under the data dir, NOT the OS temp dir: on macOS `$TMPDIR` lives
+    // under /var/folders, which container VMs (Docker Desktop, Colima, …) don't
+    // share by default, so a bind mount of it would be empty inside the
+    // container. The data dir lives under the user's home, which is shared.
+    let base = data::data_local_dir()?;
+    std::fs::create_dir_all(&base).map_err(|source| source_archive::Error::ArchiveWrite {
+        path: base.clone(),
+        source,
+    })?;
+    let tmp = tempfile::Builder::new()
+        .prefix("verifiable-src-")
+        .tempdir_in(&base)
+        .map_err(source_archive::Error::ArchiveExtract)?;
+    source_archive::unpack_targz(&bytes, tmp.path())?;
+    enforce_hardened_tree(tmp.path()).map_err(source_archive::Error::ArchiveExtract)?;
+
+    let extracted_root = tmp.path().to_path_buf();
+    Ok(ArchiveResult {
+        source_sha256: computed,
+        extracted_root,
+        tmp,
+    })
+}
+
+fn bldimg_regex() -> Regex {
+    Regex::new(r"^(?:localhost(?::\d+)?|[^\s@/]*[.:][^\s@/]*)/[^\s@]+@sha256:[0-9a-f]{64}$")
+        .unwrap()
+}
+
+fn source_sha256_regex() -> Regex {
+    Regex::new(r"^[0-9a-f]{64}$").unwrap()
+}
+
+fn source_uri_regex() -> Regex {
+    Regex::new(r"^[a-zA-Z][a-zA-Z0-9+.-]*:\S+$").unwrap()
+}
+
+/// Emit the SEP-58 `--meta` pairs recorded into the wasm: `bldimg` (the pinned
+/// image digest) first, then `source_uri`/`source_sha256` when present, then one
+/// `bldopt` per recorded build option. The bldopts already arrive as valid shell
+/// (escaped at the source in `forwarded_build_args`), so a verifier reconstructs
+/// the build by joining the recorded values and running them through a shell.
+fn build_metadata_args(image_ref: &str, ids: &SourceIds, bldopts: &[String]) -> Vec<String> {
+    let mut out = Vec::new();
+
+    let push = |out: &mut Vec<String>, key: &str, val: &str| {
+        out.push("--meta".to_string());
+        out.push(format!("{key}={val}"));
+    };
+
+    push(&mut out, "bldimg", image_ref);
+
+    if let Some(v) = &ids.source_uri {
+        push(&mut out, "source_uri", v);
+    }
+    if let Some(v) = &ids.source_sha256 {
+        push(&mut out, "source_sha256", v);
+    }
+
+    for o in bldopts {
+        push(&mut out, "bldopt", o);
+    }
+
+    out
+}
+
+/// The image to build in and record as `bldimg`: the user-supplied,
+/// digest-pinned `--image` (required by clap and already format-validated in
+/// `run`). It's a content-addressed ref, so it names the exact bytes as-is;
+/// `--pull` refreshes it up front, otherwise a missing image is fetched by the
+/// run itself, matching the plain container build.
+async fn resolve_image(cmd: &Cmd, docker: &shared::Args, print: &Print) -> Result<String, Error> {
+    let image = cmd
+        .image
+        .clone()
+        .expect("--image is required with --verifiable (enforced by clap)");
+    if cmd.pull {
+        docker.pull_image(&image, print).await?;
+    }
+    Ok(image)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn pairs(args: &[String]) -> Vec<(&str, &str)> {
+        args.chunks(2)
+            .map(|c| (c[0].as_str(), c[1].as_str()))
+            .collect()
+    }
+
+    #[test]
+    fn build_metadata_args_uri_and_sha256() {
+        let ids = SourceIds {
+            source_uri: Some("https://example.com/src.tar.gz".to_string()),
+            source_sha256: Some("a".repeat(64)),
+        };
+        let m = build_metadata_args(
+            "docker.io/stellar/stellar-cli@sha256:abc",
+            &ids,
+            &["--locked".to_string(), "--features=a".to_string()],
+        );
+        let p = pairs(&m);
+        // bldimg first; source_uri then source_sha256; bldopts last.
+        assert_eq!(
+            p[0],
+            ("--meta", "bldimg=docker.io/stellar/stellar-cli@sha256:abc")
+        );
+        assert_eq!(
+            p[1],
+            ("--meta", "source_uri=https://example.com/src.tar.gz")
+        );
+        assert_eq!(p[2].0, "--meta");
+        assert!(p[2].1.starts_with("source_sha256="));
+        assert_eq!(p[3], ("--meta", "bldopt=--locked"));
+        assert_eq!(p[4], ("--meta", "bldopt=--features=a"));
+    }
+
+    #[test]
+    fn build_metadata_args_sha256_only_omits_uri() {
+        let ids = SourceIds {
+            source_sha256: Some("f".repeat(64)),
+            ..SourceIds::default()
+        };
+        let m = build_metadata_args("docker.io/stellar/stellar-cli@sha256:abc", &ids, &[]);
+        assert!(m
+            .iter()
+            .any(|s| s == &format!("source_sha256={}", "f".repeat(64))));
+        assert!(!m.iter().any(|s| s.starts_with("source_uri=")));
+    }
+
+    #[test]
+    fn validate_source_formats_rejects_bad_sha256() {
+        let cmd = Cmd {
+            source_sha256: Some("not-a-sha".to_string()),
+            ..Cmd::default()
+        };
+        let err = validate_source_formats(&cmd).unwrap_err();
+        assert!(matches!(err, Error::SourceSha256Format { .. }));
+    }
+
+    #[test]
+    fn validate_source_formats_rejects_bad_uri() {
+        let cmd = Cmd {
+            source_uri: Some("not a uri".to_string()), // no scheme
+            source_sha256: Some("a".repeat(64)),
+            ..Cmd::default()
+        };
+        let err = validate_source_formats(&cmd).unwrap_err();
+        assert!(matches!(err, Error::SourceUriFormat { .. }));
+    }
+
+    // SEP-58 metadata must be ASCII; the URI regex's `\S` is Unicode-aware, so a
+    // non-ASCII (but otherwise well-formed) URI must still be rejected.
+    #[test]
+    fn validate_image_checks_ascii_then_format() {
+        // Non-ASCII registry/repo → rejected before the format check.
+        let err =
+            validate_image(&format!("localhost:5000/café@sha256:{}", "0".repeat(64))).unwrap_err();
+        assert!(matches!(err, Error::NonAsciiMeta { .. }), "got {err:?}");
+        // ASCII but tag-only → format error.
+        let err = validate_image("docker.io/stellar/stellar-cli:latest").unwrap_err();
+        assert!(matches!(err, Error::BldimgFormat { .. }), "got {err:?}");
+        // ASCII, digest-pinned → ok.
+        validate_image(&format!(
+            "docker.io/stellar/stellar-cli@sha256:{}",
+            "a".repeat(64)
+        ))
+        .unwrap();
+    }
+
+    #[test]
+    fn validate_source_formats_rejects_non_ascii_uri() {
+        let cmd = Cmd {
+            source_uri: Some("https://例.example/src.tar.gz".to_string()),
+            source_sha256: Some("a".repeat(64)),
+            ..Cmd::default()
+        };
+        let err = validate_source_formats(&cmd).unwrap_err();
+        assert!(matches!(err, Error::NonAsciiMeta { .. }), "got {err:?}");
+    }
+
+    #[test]
+    fn validate_source_formats_accepts_valid_and_absent() {
+        // Both absent is fine here — requiredness is enforced by clap/run().
+        validate_source_formats(&Cmd::default()).unwrap();
+        let cmd = Cmd {
+            source_uri: Some("https://example.com/src.tar.gz".to_string()),
+            source_sha256: Some("f".repeat(64)),
+            ..Cmd::default()
+        };
+        validate_source_formats(&cmd).unwrap();
+    }
+
+    #[test]
+    fn bldimg_regex_accepts_docker_hub_full_ref() {
+        assert!(bldimg_regex().is_match(&format!(
+            "docker.io/stellar/stellar-cli@sha256:{}",
+            "a".repeat(64)
+        )));
+    }
+
+    #[test]
+    fn bldimg_regex_accepts_localhost_registry() {
+        assert!(bldimg_regex().is_match(&format!("localhost:5000/foo@sha256:{}", "0".repeat(64))));
+    }
+
+    #[test]
+    fn bldimg_regex_rejects_implicit_hub_short_ref() {
+        // Implicit Docker Hub short ref: no registry host prefix.
+        assert!(!bldimg_regex().is_match(&format!("stellar/stellar-cli@sha256:{}", "a".repeat(64))));
+    }
+
+    #[test]
+    fn bldimg_regex_rejects_tag_only() {
+        assert!(!bldimg_regex().is_match("docker.io/stellar/stellar-cli:latest"));
+    }
+
+    #[test]
+    fn bldimg_regex_rejects_short_sha() {
+        assert!(!bldimg_regex().is_match("docker.io/stellar/stellar-cli@sha256:abc"));
+    }
+
+    #[test]
+    fn source_sha256_regex_matches_64_hex() {
+        assert!(source_sha256_regex().is_match(&"f".repeat(64)));
+        assert!(!source_sha256_regex().is_match(&"f".repeat(63)));
+        assert!(!source_sha256_regex().is_match(&"F".repeat(64))); // upper-case rejected
+    }
+
+    #[test]
+    fn source_uri_regex_accepts_any_scheme() {
+        assert!(source_uri_regex().is_match("https://example.com/src.tar.gz"));
+        assert!(source_uri_regex().is_match("http://example.com/foo.git"));
+        assert!(source_uri_regex().is_match("ipfs://Qm...abc"));
+        assert!(source_uri_regex().is_match("github:foo/bar"));
+        assert!(!source_uri_regex().is_match("foo/bar")); // no scheme
+        assert!(!source_uri_regex().is_match("https://has space")); // whitespace
+    }
+
+    #[test]
+    fn reserved_meta_keys_list() {
+        for key in ["bldimg", "source_uri", "source_sha256", "bldopt"] {
+            assert!(RESERVED_META_KEYS.contains(&key));
+        }
+    }
+}
diff --git a/cmd/soroban-cli/src/commands/mod.rs b/cmd/soroban-cli/src/commands/mod.rs
index 4d82ce0890..2e879e8f0d 100644
--- a/cmd/soroban-cli/src/commands/mod.rs
+++ b/cmd/soroban-cli/src/commands/mod.rs
@@ -33,6 +33,7 @@ pub const HEADING_GLOBAL: &str = "Global Options";
 pub const HEADING_SIGNING: &str = "Signing Options";
 pub const HEADING_TRANSACTION: &str = "Transaction Options";
 pub const HEADING_CONTAINER: &str = "Container Options";
+pub const HEADING_VERIFIABLE: &str = "Verifiable Options";
 const ABOUT: &str =
     "Work seamlessly with Stellar accounts, contracts, and assets from the command line.
 
diff --git a/cmd/soroban-cli/src/config/data.rs b/cmd/soroban-cli/src/config/data.rs
index db123741a3..b726ab838d 100644
--- a/cmd/soroban-cli/src/config/data.rs
+++ b/cmd/soroban-cli/src/config/data.rs
@@ -59,6 +59,12 @@ pub fn bucket_dir() -> Result<std::path::PathBuf, Error> {
     Ok(dir)
 }
 
+pub fn archives_dir() -> Result<std::path::PathBuf, Error> {
+    let dir = data_local_dir()?.join("archives");
+    std::fs::create_dir_all(&dir)?;
+    Ok(dir)
+}
+
 pub fn write(action: Action, rpc_url: &Url) -> Result<ulid::Ulid, Error> {
     let data = Data {
         action,
@@ -213,6 +219,18 @@ mod test {
     use crate::test_utils::with_env_set;
     use serial_test::serial;
 
+    #[test]
+    #[serial]
+    fn archives_dir_under_data_home_and_created() {
+        let t = assert_fs::TempDir::new().unwrap();
+        with_env_set("STELLAR_DATA_HOME", t.path(), || {
+            let dir = archives_dir().unwrap();
+            assert!(dir.ends_with("archives"));
+            assert!(dir.starts_with(t.path()));
+            assert!(dir.is_dir(), "archives_dir() should create the directory");
+        });
+    }
+
     #[test]
     #[serial]
     fn test_write_read() {